#!/usr/bin/python3 if __name__ == "__main__": import module.ctrl as ctrl ctr = ctrl.Ctrl() ctr.run() else: import sdl2 import sdl2.ext import random sdl2.ext.init() window = sdl2.ext.Window("Triggered", size=(320, 371)) window.show() RESOURCES = sdl2.ext.Resources(__file__, "./res") factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE) sprite = factory.from_image(RESOURCES.get_path("triggered.png")) spriterenderer = factory.create_sprite_render_system(window) running = True while running: events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break sprite.position = random.randrange(-5, 6), random.randrange(-5, 6) spriterenderer.render(sprite) sdl2.SDL_Delay(16) window.hide()
def run(): out_blocks = "" out_images = "" all_blocks = [] sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO | sdl2.SDL_INIT_EVERYTHING) sdl_image.IMG_Init(sdl_image.IMG_INIT_PNG) window = sdl2.ext.Window("BAConv", size=(1024, 384)) window.show() ren = sdl2.ext.Renderer(window, flags=sdl2.SDL_RENDERER_ACCELERATED) # makes zoomed graphics blocky (for retro effect) sdl2.SDL_SetHint(sdl2.SDL_HINT_RENDER_SCALE_QUALITY, b"nearest") # makes the graphics look and act like the desired screen size, even though they may be rendered at a different one sdl2.SDL_RenderSetLogicalSize(ren.sdlrenderer, 256, 96) max_blocks = 0 total_blocks = 0 count = 0 limit = 100 # pass 1 - gather all the blocks for i in range(0, int(6565 / 4)): count += 1 if count > limit: # stop early break events = sdl2.ext.get_events() # otherwise window doesn't update ren.clear() file = f"image-{i*4+1:03}.png" sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8')) image, blocks = processImage( file, ren) # also draws left hand side pre-processed # add blocks to master list for i, block in enumerate(blocks): found = False for j, b in enumerate(all_blocks): if block == b: # better match found update existing record all_blocks[j].count += blocks[i].count found = True # found a match of some sort if not found: # totally new block all_blocks.append(block) num_blocks = len(blocks) total_blocks += num_blocks if max_blocks < num_blocks: max_blocks = num_blocks renderImage(image, blocks, ren) # right hand side post-process sdl2.SDL_RenderPresent(ren.sdlrenderer) window.refresh() print(f"Max blocks: {max_blocks}") print(f"Total blocks: {total_blocks}") print(f"Average blocks: {total_blocks/count}") print(f"Processed {count} frames.") # sort and choose top blocks all_blocks.sort(reverse=True) # 1024 is currently all you're planning to store # todo: choose final number of blocks to use # all_blocks=all_blocks[0:1024] for i, b in enumerate(all_blocks): print(f"Block {i}: {b.count}") # pass 2 - build new images with top blocks all_images = [] count = 0 for i in range(43, int(6509 / 2)): count += 1 if count > limit: # stop early break ren.clear() file = f"image-{i*2+1:03}.png" sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8')) image = reprocessImage( file, ren, all_blocks) # also draws left hand side pre-processed all_images.append(image) renderImage(image, all_blocks, ren) # right hand side post-process events = sdl2.ext.get_events() # otherwise window doesn't update sdl2.SDL_RenderPresent(ren.sdlrenderer) window.refresh() fr = 0 while True: fr = (fr + 1) % len(all_images) events = sdl2.ext.get_events() # otherwise window doesn't update ren.clear() file = f"image-{i*2+1:03}.png" sdl2.SDL_SetWindowTitle(window.window, file.encode('utf-8')) renderImage(all_images[fr], all_blocks, ren) sdl2.SDL_RenderPresent(ren.sdlrenderer) window.refresh() sdl2.SDL_Delay(10)
def main(): from os import sys if len(sys.argv) <= 1: show_commandline_help() import font from font import Font import layers from layers import HDTextLayer, TextLayer import time import sdl2 t0 = time.clock() import ctypes from ctypes import byref, cast, POINTER, c_int, c_float, sizeof, c_uint32, c_double, c_voidp, c_void_p from sdl2 import endian exp_font_name = sys.argv[1] font_size = 48 if len(sys.argv) > 2: font_size = int(sys.argv[2]) sdl2_DisplayManager.Init(10, 10, 1) sdl2_DisplayManager.inst().fonts_init("Courier", "HHSam") font_path = match_font(exp_font_name) #"coalition") sdl2_DisplayManager.inst().font_add( font_path=font_path, font_alias="export_font", size=font_size) #, color=None, bgcolor=None) char_size = 0 lChars = [chr(i + ord(' ')) for i in xrange(0, 95)] for char_offset, c in zip(xrange(0, 95), lChars): # surf = f.textHollow(c, line_color, interior_color, line_width, fill_color) (font_width, font_height) = sdl2_DisplayManager.inst().font_get_size( c, 'export_font', font_size) char_size = max(char_size, font_width, font_height) width = height = char_size * 10 font_sizes = '' # hack stuff to re-attach the correctly sized window sdl2_DisplayManager.inst().window = sdl2.ext.Window("Font Preview", size=(width, height)) sdl2_DisplayManager.inst().texture_renderer = sdl2.ext.Renderer( sdl2_DisplayManager.inst().window) sdl2_DisplayManager.inst().fill = sdl2_DisplayManager.inst( ).texture_renderer.fill sdl2_DisplayManager.inst().clear = sdl2_DisplayManager.inst( ).texture_renderer.clear sdl2_DisplayManager.inst().factory = sdl2.ext.SpriteFactory( renderer=sdl2_DisplayManager.inst().texture_renderer) sdl2_DisplayManager.inst().show_window() frame = Frame(width, height) #BGR? interior_color = (255, 255, 255) line_width = 0 #fill_color = (255,0,0) line_color = (1, 1, 1) for char_offset, c in zip(xrange(0, 95), lChars): # surf = f.textHollow(c, line_color, interior_color, line_width, fill_color) surf = sdl2_DisplayManager.inst().font_render_bordered_text( c, font_alias='export_font', size=font_size, border_width=line_width, border_color=line_color, color=interior_color) (w, h) = surf.size (font_width, font_height) = sdl2_DisplayManager.inst().font_get_size( c, 'export_font', font_size) #font_sizes += format(font_width,'x') font_sizes += str(font_width) font_sizes += "," F = Frame(width=w, height=h, from_surface=surf) char_x = char_size * (char_offset % 10) char_y = char_size * (char_offset / 10) Frame.copy_rect(dst=frame, dst_x=char_x, dst_y=char_y, src=F, src_x=0, src_y=0, width=w, height=h, op='copy') #x += width + self.tracking sdl2_DisplayManager.inst().screen_blit( source_tx=frame.pySurface, expand_to_fill=True) #, area=(10,10,400,200)) texture_renderer = sdl2_DisplayManager.inst().texture_renderer bk = sdl2.SDL_GetRenderTarget(texture_renderer.renderer) t = sdl2.render.SDL_CreateTexture(texture_renderer.renderer, sdl2.pixels.SDL_PIXELFORMAT_RGBA8888, sdl2.render.SDL_TEXTUREACCESS_STREAMING, width, height) #create a new texture and blit the frame to it, then grab bits from that texture_renderer.clear((0, 0, 0, 0)) sdl2.SDL_SetRenderTarget(texture_renderer.renderer, t) #sdl2_DisplayManager.inst().blit(source_tx=frame.pySurface, dest_tx = t, dest = (0,0,512,512)) texture_renderer.copy(frame.pySurface, (0, 0, width, height), (0, 0, width, height)) pitch = c_int() bytes = c_void_p() rect = sdl2.SDL_Rect(0, 0, width, height) sdl2.SDL_LockTexture(t, rect, ctypes.byref(bytes), ctypes.byref(pitch)) if endian.SDL_BYTEORDER == endian.SDL_LIL_ENDIAN: rmask = 0x000000FF gmask = 0x0000FF00 bmask = 0x00FF0000 amask = 0xFF000000 else: rmask = 0xFF000000 gmask = 0x00FF0000 bmask = 0x0000FF00 amask = 0x000000FF print rmask imgsurface = sdl2.surface.SDL_CreateRGBSurfaceFrom(bytes, width, height, 32, pitch, rmask, gmask, bmask, amask) if not imgsurface: raise sdl2.ext.SDLError() sdl2.SDL_RenderReadPixels(texture_renderer.renderer, rect, 0, bytes, pitch) sdl2.SDL_SaveBMP(imgsurface, 'image.png') #4) Restore renderer's texture target sdl2.SDL_SetRenderTarget(texture_renderer.renderer, bk) #ss = sdl2.ext.SoftwareSprite(surf, True) #ss = sdl2.ext.SoftwareSprite(imgsurface, True) #sdl2.SDL_SaveBMP(ss.contents, "file.bmp") # # print font_sizes sdl2_DisplayManager.inst().flip() sdl2.SDL_Delay(2)
def main(): #cause I don't want to pass these around global REN, SPRITE_FACTORY, SPRITE_RENDERER global RESET_BUTTON, NEW_BUTTON, SOLVE_BUTTON sdl2.ext.init() window = sdl2.ext.Window("Slide Puzzle", size=(WINDOWWIDTH, WINDOWHEIGHT)) REN = sdl2.ext.Renderer(window) window.show() font_file = sysfont.get_font("freesans", sysfont.STYLE_BOLD) font_manager = sdl2.ext.FontManager(font_file, size=BASICFONTSIZE) #fontmanager=font_manager will be default_args passed to every sprite creation method SPRITE_FACTORY = sdl2.ext.SpriteFactory(renderer=REN, fontmanager=font_manager, free=True) SPRITE_RENDERER = SPRITE_FACTORY.create_sprite_render_system(window) RESET_BUTTON, reset_rect = make_text(SPRITE_FACTORY, "Reset", WINDOWWIDTH - 120, WINDOWHEIGHT - 90, bg_color=TILECOLOR) NEW_BUTTON, new_rect = make_text(SPRITE_FACTORY, "New Game", WINDOWWIDTH - 120, WINDOWHEIGHT - 60, bg_color=TILECOLOR) SOLVE_BUTTON, solve_rect = make_text(SPRITE_FACTORY, "Solve", WINDOWWIDTH - 120, WINDOWHEIGHT - 30, bg_color=TILECOLOR) mainBoard, solutionSeq = generateNewPuzzle(NUMSLIDES) SOLVEDBOARD = getStartingBoard( ) # a solved board is the same as the board in a start state. allMoves = [] # list of moves made from the solved configuration print(NEW_BUTTON.area) running = True while running: slideTo = None # the direction, if any, a tile should slide msg = 'Click tile or press arrow keys to slide.' # contains the message to show in the upper left corner. if mainBoard == SOLVEDBOARD: msg = 'Solved!' drawBoard(mainBoard, msg) for event in sdl2.ext.get_events(): if event.type == sdl2.SDL_QUIT: running = False break elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_EXPOSED: print("window exposed") drawBoard(mainBoard, msg) elif event.type == sdl2.SDL_MOUSEBUTTONUP: pos = event.button.x, event.button.y spotx, spoty = getSpotClicked(mainBoard, pos[0], pos[1]) pt = sdl2.SDL_Point(pos[0], pos[1]) if (spotx, spoty) == (None, None): if sdl2.SDL_PointInRect(pt, reset_rect): resetAnimation(mainBoard, allMoves) allMoves = [] elif sdl2.SDL_PointInRect(pt, new_rect): mainBoard, solutionSeq = generateNewPuzzle(NUMSLIDES) allMoves = [] elif sdl2.SDL_PointInRect(pt, solve_rect): resetAnimation(mainBoard, solutionSeq + allMoves) allMoves = [] else: #check if clicked tile was next to blank blankx, blanky = getBlankPosition(mainBoard) if spotx == blankx + 1 and spoty == blanky: slideTo = LEFT elif spotx == blankx - 1 and spoty == blanky: slideTo = RIGHT elif spotx == blankx and spoty == blanky + 1: slideTo = UP elif spotx == blankx and spoty == blanky - 1: slideTo = DOWN elif event.type == sdl2.SDL_KEYUP: # check if the user pressed a key to slide a tile sym = event.key.keysym.sym if sym in (sdl2.SDLK_LEFT, sdl2.SDLK_a) and isValidMove( mainBoard, LEFT): slideTo = LEFT elif sym in (sdl2.SDLK_RIGHT, sdl2.SDLK_d) and isValidMove( mainBoard, RIGHT): slideTo = RIGHT elif sym in (sdl2.SDLK_UP, sdl2.SDLK_w) and isValidMove( mainBoard, UP): slideTo = UP elif sym in (sdl2.SDLK_DOWN, sdl2.SDLK_s) and isValidMove( mainBoard, DOWN): slideTo = DOWN elif event.key.keysym.sym == sdl2.SDLK_ESCAPE: running = False break if slideTo: slideAnimation(mainBoard, slideTo, 'Click tile or press arrow keys to slide.', 8) # show slide on screen allMoves.append(slideTo) # record the slide REN.present() sdl2.SDL_Delay(1000 // FPS) sdl2.ext.quit()
def sleep(self, ms): """Sleep a tick to avoid hogging the cpu.""" sdl2.SDL_Delay(ms)
video.SDL_GL_CONTEXT_PROFILE_CORE) context = sdl2.SDL_GL_CreateContext(window) glClearColor(0.5, 0.5, 0.5, 1.0) glEnable(GL_DEPTH_TEST) glViewport(0, 0, 800, 600) shader = OpenGL.GL.shaders.compileProgram( shaders.compileShader(vertex_shader, GL_VERTEX_SHADER), shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER)) vertex_array_object, vertex_buffer = create_vbo(shader) event = sdl2.SDL_Event() running = True while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE): running = False render() sdl2.SDL_GL_SwapWindow(window) sdl2.SDL_Delay(10) sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
def run(): global button_alpha sdl2.ext.init() #container = av.open(RESOURCES.get_path("darknet.mp4")) container = av.open(RESOURCES.get_path("BOKK (loop)-162670765.mp4")) video = next(s for s in container.streams) W = video.format.width H = video.format.height window = sdl2.ext.Window("Hello World!", size=(W, H)) window.show() print("Using hardware acceleration") renderer = sdl2.ext.Renderer(window) factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer) sprite = factory.from_color(sdl2.ext.Color(r=255, g=255, b=255, a=255), size=(W, H)) uifactory = sdl2.ext.UIFactory(factory) button = uifactory.from_image(sdl2.ext.BUTTON, RESOURCES.get_path("button.png")) button.position = 200, 160 processor = sdl2.ext.TestEventProcessor() button.click += onclick spriterenderer = factory.create_sprite_render_system(window) uiprocessor = sdl2.ext.UIProcessor() sdl2.render.SDL_SetTextureAlphaMod(button.texture, 255) font_mgr = sdl2.ext.FontManager(RESOURCES.get_path("Arial Bold.ttf"), size=160, color=RED) print(dir(renderer)) #texture = sdl2.render.SDL_CreateTexture(renderer.renderer, sdl2.SDL_PIXELFORMAT_RGBA8888, sdl2.SDL_TEXTUREACCESS_STREAMING, W, H) running = True # while running: for packet in container.demux(video): fps = packet.duration // 10 dec = packet.decode() for frame in dec: sdl2.render.SDL_SetRenderDrawColor(renderer.renderer, 255, 128, 128, 255) sdl2.render.SDL_RenderClear(renderer.renderer) # frame = clip.get_frame(t) pixels = frame.to_rgb().to_nd_array().ctypes.data_as( ctypes.c_void_p) surface = sdl2.surface.SDL_CreateRGBSurfaceFrom( pixels, W, H, 8 * 3, 3 * W, 0x0000FF, 0x00FF00, 0x00FF00, 1) tex = sdl2.render.SDL_CreateTextureFromSurface( renderer.renderer, surface) events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break # Pass the SDL2 events to the UIProcessor, which takes care of # the user interface logic. uiprocessor.dispatch([ button, ], event) # Render all user interface elements on the window. text_sprite = factory.from_text( text, fontmanager=font_mgr) # Creating TextureSprite from Text text_sprite.position = 10, 10 sprite.texture = tex sdl2.render.SDL_SetTextureAlphaMod(sprite.texture, button_alpha) spriterenderer.render((sprite, button, text_sprite)) sdl2.surface.SDL_FreeSurface(surface) sdl2.render.SDL_DestroyTexture(tex) sdl2.SDL_Delay(10) sdl2.ext.quit() return 0
def delay(self, ms): ''' Задержка в ms * @returns {self} ''' SDL.SDL_Delay(ms) return self
raise RuntimeError("Cannot initialize audio system: {}".format( sdl2.SDL_GetError())) # int Mix_OpenAudio(int frequency, Uint16 format, int channels, int chunksize) if sdlmixer.Mix_OpenAudio(44100, sdlmixer.MIX_DEFAULT_FORMAT, 2, 1024): raise RuntimeError("Cannot open mixed audio: {}".format( sdlmixer.Mix_GetError())) sdlmixer.Mix_AllocateChannels(64) sound_file = RESOURCES.get_path("Cat.wav") sample = sdlmixer.Mix_LoadWAV(sdl2.ext.compat.byteify(sound_file, "utf-8")) if sample is None: raise RuntimeError("Cannot open audio file: {}".format( sdlmixer.Mix_GetError())) count = 5 while count > 0: channel = sdlmixer.Mix_PlayChannel(channel=-1, chunk=sample, loops=0) sdlmixer.Mix_SetPosition(channel, 270, 100) print(channel) if channel == -1: raise RuntimeError("Cannot play sample: {}".format( sdlmixer.Mix_GetError())) # while sdlmixer.Mix_Playing(channel): sdl2.SDL_Delay(800) count -= 1 sdlmixer.Mix_CloseAudio() sdl2.SDL_Quit(sdl2.SDL_INIT_AUDIO)
import logging import math import numpy as np import sdl2 import sdl2.ext from sdl2 import sdlgfx width = 800 height = 600 sdl2.ext.init() window = sdl2.ext.Window('window_title', size=(width, height)) window.show() context = sdl2.ext.Renderer(window) sdlgfx_green = 0xFFFFFFFF # 255 << 8 t = 0 while True: context.clear(0) t += 1 r = int(20 * (math.sin(t / 20) + 1)) print(r) for i in range(0, 800, 20): for j in range(0, 600, 20): sdlgfx.circleColor(context.sdlrenderer, i, j, r, sdlgfx_green) context.present() sdl2.SDL_Delay(20)
def main(): sdl2.ext.init() # Create the window window = sdl2.ext.Window("Foo", size=(960, 640)) window.show() # Create the spirte factory and the sprite for the player factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE) # Create the worl and spriterenderer system world = sdl2.ext.World() spriterenderer = SoftwareRenderer(window) movement = MovementSystem(0, 0, 960, 640) playerMovement = PlayerMovementSystem() collision = CollisionSystem() battleSystem = BattleSystem() # Add all systems to the world world.add_system(playerMovement) world.add_system(collision) world.add_system(movement) world.add_system(spriterenderer) world.add_system(battleSystem) # Test map generation grid = mapGen.buildMap(world, factory, 4) grid.build(world, factory) enemyTile = random.choice(grid.tiles) enemy = Enemy(world, factory, enemyTile.position.x, enemyTile.position.y) # Pick random location for player playerTile = random.choice(grid.tiles) player = Player(world, factory, playerTile.position.x, playerTile.position.y) player_speed = 1 battleSystem.player = player playerMovement.player = player playerMovement.grid = grid gridSystem = GridSystem(960, 640, player) world.add_system(gridSystem) # Colliders for said items collision.player = player collision.grid = grid # Main event loop running = True key_down = False while(running): events = sdl2.ext.get_events() for event in events: # Hittin' dat X button doe if event.type == sdl2.SDL_QUIT: running = False break if event.type == sdl2.SDL_KEYUP: key_down = False # Movement if event.type == sdl2.SDL_KEYDOWN: d = None if(not key_down): if event.key.keysym.sym == sdl2.SDLK_UP: d = Direction.NORTH key_down = True elif event.key.keysym.sym == sdl2.SDLK_e: print("I'm attacking with", player.get_damage(), "!") key_down = True elif event.key.keysym.sym == sdl2.SDLK_f: print("Consuming") player.consume() print("Player health now at,", player.playerdata.health) elif event.key.keysym.sym == sdl2.SDLK_DOWN: d = Direction.SOUTH key_down = True elif event.key.keysym.sym == sdl2.SDLK_LEFT: d = Direction.EAST key_down = True elif event.key.keysym.sym == sdl2.SDLK_RIGHT: d = Direction.WEST key_down = True if d != None: collision.player_dir = d enemy.random_move(grid) playerMovement.walk(d) sdl2.SDL_Delay(10) world.process() return 0
def main(): if len(sys.argv) < 3: print("Please provide player file name and player id") sys.exit(1) gameplay.state.my_player_id = None players_str = None with open(sys.argv[1], "r") as player_file: gameplay.state.my_player_id = int(sys.argv[2]) players_str = player_file.read() player_adds = players_str.split() num_players = len(player_adds) messaging = MessagingHandler() messaging.connect(player_adds, num_players, gameplay.state.my_player_id) graphics.view.initView() graphics.view.makeGameSubView() running = True gameplay.state.floor = Floor() gameplay.state.floor.genFloor(10, 25) gameplay.state.players = [] sim = Simulation() for i in range(num_players): gameplay.state.players.append(Player(i, 50 * i, 50)) sim.add_object(gameplay.state.players[i].collider) gameplay.state.floor.board[0][0] = Room() gameplay.state.floor.board[0][0].enemies = [] gameplay.state.floor.board[0][0].enemies.append(Monster(0, 100, 100)) sim.add_object(gameplay.state.floor.board[0][0].enemies[0].collider) last_phys_time = sdl2.SDL_GetTicks() while running == True: frame_start = sdl2.SDL_GetTicks() input_events = sdl2.ext.get_events() game_events = [] for event in input_events: if event.type == sdl2.SDL_QUIT: running = False break else: if not ControlsState.should_process_input_event(event): continue ControlsState.update_state(event) player_event = gameplay.state.players[gameplay.state.my_player_id].processInputEvent(event) if player_event.params["code"] == "NONE": continue game_events.append(player_event) messaging.broadcast(player_event.serialize().encode("utf-8")) for enemy in gameplay.state.floor.board[0][0].enemies: enemy.chooseNewDirection(gameplay.state.players) messages = messaging.get_messages() while messages.qsize() > 0: msg = messages.get() game_events.append(GameEvent.deserialize(msg.decode("utf-8"))) for event in game_events: if (event.params["type"] == "PLAYER"): gameplay.state.players[event.params["player_id"]].processPlayerEvent(event) curr_time = sdl2.SDL_GetTicks() delta = curr_time - last_phys_time last_phys_time = curr_time sim.step(delta / 1000) graphics.view.render() frame_end = sdl2.SDL_GetTicks() remaining_time = (frame_start + FRAME_LENGTH) - frame_end if remaining_time > 0: sdl2.SDL_Delay(remaining_time) sdl2.ext.quit()
def run(): global camera, STEPS_PER_FRAME, world, astronomical_objects, stars astronomical_objects = [] stars = [] sdl2.ext.init() window = sdl2.ext.Window("Solar Orbiters", size=WINDOW_SIZE) window.show() if True: print("Using hardware acceleration") renderer = sdl2.ext.Renderer(window) factory = sdl2.ext.SpriteFactory(sdl2.ext.TEXTURE, renderer=renderer) else: print("Using software rendering") factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE) world = sdl2.ext.World() if factory.sprite_type == sdl2.ext.SOFTWARE: spriterenderer = SoftwareRenderSystem(window) else: spriterenderer = TextureRenderSystem(renderer) movementsystem = MovementSystem() spritemovementsystem = SpriteMovementSystem() camera = Camera3D() world.add_system(movementsystem) world.add_system(spritemovementsystem) world.add_system(spriterenderer) # Instantiate stars for x, y, z in generate_random_directions(NUM_OF_STARS): stars.append(Star(world, x, y, z)) # Parse solar system data from xml tree = ET.parse(ASTRO_OBJECTS_XML_PATH) root = tree.getroot() # Instantiate planets for astro_object in root.findall('object'): if not MAKE_PLANETS: break color_elem = astro_object.find('color') color = sdl2.ext.Color(int(color_elem[0].text), int(color_elem[1].text), int(color_elem[2].text)) diameter = max(1, int(float(astro_object.find('diameter').text) * 10)) sprite = factory.from_color(color, size=(diameter, diameter)) mass = (float(astro_object.find('mass').text) * 10**int(astro_object.find('mass')[0].text)) radius = 10000 # Temporary test number. x = int(astro_object.find('position').find('x').text) * 1000 y = int(astro_object.find('position').find('y').text) * 1000 z = int(astro_object.find('position').find('z').text) * 1000 vx = float(astro_object.find('velocity').find('x').text) * 1000 vy = float(astro_object.find('velocity').find('y').text) * 1000 vz = float(astro_object.find('velocity').find('z').text) * 1000 astronomical_objects.append( AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy, vz)) # Instantiate some Trojans... or were they Greeks? mass = 100 origin = 778412010000 x0 = origin * math.cos(math.pi / 3) y0 = origin * math.sin(math.pi / 3) z0 = 0 radius = 1e11 vel0 = 13.0697 * 1000 vx0 = vel0 * math.cos(math.pi / 3 + math.pi / 2) vy0 = vel0 * math.sin(math.pi / 3 + math.pi / 2) vz0 = 0 v_deviation = 200 for i in range(TROJANS): sprite = factory.from_color(GRAY, size=(2, 2)) x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, radius, 0, vx0, vy0, vz0, v_deviation) asteroid_radius = 10000 # Test variable, no real effect yet. astronomical_objects.append( AstronomicalObject(world, sprite, mass, asteroid_radius, x, y, z, vx, vy, vz)) # Instantiate some Jupiter Orbiters mass = 100 x0 = 778412010000 y0 = 0 z0 = 0 max_radius = 1e11 min_radius = 1e7 vx0 = 0 vy0 = 13.0697 * 1000 vz0 = 0 v_deviation = 1e3 radius = 10000 # Temporary test number. for i in range(JUPITER_ORBITERS): sprite = factory.from_color(GRAY, size=(2, 2)) x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, max_radius, min_radius, vx0, vy0, vz0, v_deviation) astronomical_objects.append( AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy, vz)) # Instantiate some random asteroids. mass = 100 x0 = 0 y0 = 0 z0 = 0 max_radius = 1e12 min_radius = 1e7 vx0 = 0 vy0 = 0 vz0 = 0 v_deviation = 1e5 radius = 10000 # Temporary test number. for i in range(FREE_ASTEROIDS): sprite = factory.from_color(GRAY, size=(2, 2)) x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, max_radius, min_radius, vx0, vy0, vz0, v_deviation) astronomical_objects.append( AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy, vz)) # Instantiate some random planetoids. # Pretty messy. Should clean up a bit. mass = 1e28 x0 = 0 y0 = 0 z0 = 0 max_radius = 1e12 min_radius = 1e7 vx0 = 0 vy0 = 0 vz0 = 0 v_deviation = 1e4 radius = 10000 # Temporary test number. for i in range(EXTRA_PLANETOIDS): sprite = factory.from_color(GRAY, size=(10, 10)) x, y, z, vx, vy, vz = generate_asteroid_data(x0, y0, z0, max_radius, min_radius, vx0, vy0, vz0, v_deviation) astronomical_objects.append( AstronomicalObject(world, sprite, mass, radius, x, y, z, vx, vy, vz)) running = True # An input dictionary for continuous input. keymap_dict = { 'translate-left': sdl2.SDLK_j, 'translate-right': sdl2.SDLK_l, 'translate-up': sdl2.SDLK_i, 'translate-down': sdl2.SDLK_k, 'translate-forward': sdl2.SDLK_h, 'translate-backward': sdl2.SDLK_n, 'zoom-in': sdl2.SDLK_x, 'zoom-out': sdl2.SDLK_z, 'pitch-down': sdl2.SDLK_w, 'pitch-up': sdl2.SDLK_s, 'yaw-left': sdl2.SDLK_a, 'yaw-right': sdl2.SDLK_d, 'roll-left': sdl2.SDLK_q, 'roll-right': sdl2.SDLK_e } input_set = set() while running: for event in sdl2.ext.get_events(): if event.type == sdl2.SDL_QUIT: running = False break elif event.type == sdl2.SDL_KEYDOWN: # The repeat delay is useful for speeding up or slowing down # the simulation, but not for camera rotation. if event.key.keysym.sym == sdl2.SDLK_PERIOD: STEPS_PER_FRAME += 1 elif event.key.keysym.sym == sdl2.SDLK_COMMA: STEPS_PER_FRAME = max(0, STEPS_PER_FRAME - 1) else: input_set.add(event.key.keysym.sym) elif event.type == sdl2.SDL_KEYUP: try: input_set.remove(event.key.keysym.sym) except: # Ignore orphan KEYUP events. pass if keymap_dict['translate-forward'] in input_set: camera.translate(0.5, 0, 0) if keymap_dict['translate-backward'] in input_set: camera.translate(-0.5, 0, 0) if keymap_dict['translate-up'] in input_set: camera.translate(0, 0.5, 0) if keymap_dict['translate-down'] in input_set: camera.translate(0, -0.5, 0) if keymap_dict['translate-left'] in input_set: camera.translate(0, 0, -0.5) if keymap_dict['translate-right'] in input_set: camera.translate(0, 0, 0.5) if keymap_dict['zoom-in'] in input_set: camera.zoom(0.1) if keymap_dict['zoom-out'] in input_set: camera.zoom(-0.1) if keymap_dict['pitch-down'] in input_set: camera.pitch(0.03) if keymap_dict['pitch-up'] in input_set: camera.pitch(-0.03) if keymap_dict['yaw-left'] in input_set: camera.yaw(-0.03) if keymap_dict['yaw-right'] in input_set: camera.yaw(0.03) if keymap_dict['roll-left'] in input_set: camera.roll(-0.03) if keymap_dict['roll-right'] in input_set: camera.roll(0.03) sdl2.SDL_Delay(10) world.process()
def run(): sdl2.ext.init() window = sdl2.ext.Window("Parallax Scroll", size=window_size) world = sdl2.ext.World() renderer = sdl2.ext.Renderer(window) renderer.blendmode = sdl2.SDL_BLENDMODE_NONE if txtr == 1: sprite_factory = sdl2.ext.SpriteFactory(renderer=renderer) else: sprite_factory = sdl2.ext.SpriteFactory(sprite_type=sdl2.ext.SOFTWARE, renderer=renderer) sprite_render_system = sprite_factory.create_sprite_render_system(window) print("created sprite render system " + str(type(sprite_render_system))) movement = move(0, 0, window_size[0], window_size[1]) rands = [] #([],[],[]) for i in range(0, (window_size[1] / 2) * 3): #print(i) for j in range(0, 3): #print(j) if txtr == 1: sprite = sprite_factory.create_texture_sprite(renderer, (8, 8)) else: sprite = sprite_factory.create_software_sprite((8, 8)) sprite.fill((255, 0, 255, 0.5)) #sprite.from init_sprite_loc(sprite) vel = Velocity() vel.vy = j vels.append(vel) #rands[j].append((vel, sprite)) rands.append(sprite) noise_obj(world, sprite, vel) #print(rands) window.show() #divide in half whatever the desired percentage of the screen is (0.5 becomes 0.25, 0.8 would be 0.4) for i in range(0, int(window_size[1] * percentage // 2.0)): renderer.draw_line((0, (window_size[1] / 2) - i - 2, window_size[0], (window_size[1] / 2) - i - 2), (0x000000FF)) renderer.draw_line((0, (window_size[1] / 2) - i - 1, window_size[0], (window_size[1] / 2) - i - 1), (0x000000FF)) renderer.draw_line((0, (window_size[1] / 2) - i, window_size[0], (window_size[1] / 2) - i), (0x000000AF)) renderer.draw_line((0, (window_size[1] / 2) + i, window_size[0], (window_size[1] / 2) + i), (0x000000AF)) renderer.draw_line((0, (window_size[1] / 2) + i + 1, window_size[0], (window_size[1] / 2) + i + 1), (0x000000FF)) renderer.draw_line((0, (window_size[1] / 2) + i + 2, window_size[0], (window_size[1] / 2) + i + 2), (0x000000FF)) renderer.present() sdl2.SDL_Delay(10) world.add_system(movement) #print(world.systems) running = True while running: events = sdl2.ext.get_events() #for i in range(0, 300): sprite_render_system.render(rands) renderer.present() for event in events: if event.type == sdl2.SDL_QUIT or (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE): running = False break #sdl2.SDL_Delay(33) world.process() sprite_render_system.render(rands) #, clear=True) #renderer.clear() renderer.present() #refresh only needed for sw/surface window.refresh() return 0
def frame_limiter(self, speed): now = sdl2.SDL_GetTicks() delay = int(1000.0 / (60.0 * speed) - (now - self._ticks)) sdl2.SDL_Delay(delay if delay > 0 else 0) self._ticks = sdl2.SDL_GetTicks()
def _sleep(self): """ Sleep a tick to avoid hogging the cpu. """ sdl2.SDL_Delay(tick_ms)
def main(): sdl2.sdl2_load( ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib' ttf_libpath=ctypes.util.find_library('SDL2_ttf'), img_libpath=ctypes.util.find_library('SDL2_image'), gfx_libpath=ctypes.util.find_library('SDL2_gfx')) sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) WINDOW_W = 640 WINDOW_H = 360 window = sdl2.SDL_CreateWindow(b"Minimal SDL2_gfx Test via python-sdl2", 0, 0, WINDOW_W, WINDOW_H, sdl2.SDL_WINDOW_OPENGL) renderer = sdl2.SDL_CreateRenderer(window, -1, 0) fpsdelay = 100 count = 0 event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type # event_timestamp = event.common.timestamp # print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) ) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: done = True sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF) sdl2.SDL_RenderClear(renderer) sdl2.pixelColor(renderer, 100, 100, 0xFFFFFFFF) # Uint32 color = 0x[AA][BB][GG][RR] sdl2.pixelRGBA(renderer, 101, 100, 0xFF, 0x00, 0x00, 0xFF) sdl2.hlineColor(renderer, 0, 100, 50, 0xFFFFFFFF) sdl2.vlineColor(renderer, 50, 0, 100, 0xFFFF00FF) sdl2.rectangleColor(renderer, 5, 5, 95, 95, 0xFF00FFFF) sdl2.rectangleRGBA(renderer, 10, 10, 90, 90, 0, 0, 0xFF, 0xFF) sdl2.circleColor(renderer, 150, 150, 50, 0xFF00FF00) sdl2.filledCircleRGBA(renderer, 150, 150, 45, 0x00, 0xFF, 0x00, 0xFF) sdl2.aalineColor(renderer, 200, 200, 300, 300, 0xFFFFFFFF) sdl2.aalineColor(renderer, 300, 200, 200, 300, 0xFFFFFFFF) sdl2.aacircleColor(renderer, 300, 200, 25, 0xFF00FF00) sdl2.pieColor(renderer, 200, 300, 25, 0, 270, 0xFF00FF00) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_Delay(fpsdelay) sdl2.IMG_Quit() sdl2.SDL_DestroyRenderer(renderer) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
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 SoftSpriteRenderSystem, 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
def run(): lib.init() window = lib.Window('RLSnake', size=(window_width, window_height)) window.show() renderer = lib.Renderer(window) font_manager = sdl2.ext.FontManager( font_path="assets/fonts/Roboto-Regular.ttf", size=14) factory = sdl2.ext.SpriteFactory(renderer=renderer) text = factory.from_text("Current score: ", fontmanager=font_manager) snake = Snake(n_grid_x, n_grid_y) snake.reset() moves = 0 running = True game_over = False current_tiles = snake.get_tiles() while running: events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break if event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: running = False break if event.key.keysym.sym == 114: snake.reset() game_over = False current_tiles = snake.get_tiles() moves = 0 break if not game_over: if event.key.keysym.sym == sdl2.SDLK_UP: _, game_over, _ = snake.step(3) current_tiles = snake.get_tiles() moves += 1 elif event.key.keysym.sym == sdl2.SDLK_DOWN: _, game_over, _ = snake.step(2) current_tiles = snake.get_tiles() moves += 1 elif event.key.keysym.sym == sdl2.SDLK_LEFT: _, game_over, _ = snake.step(1) current_tiles = snake.get_tiles() moves += 1 elif event.key.keysym.sym == sdl2.SDLK_RIGHT: _, game_over, _ = snake.step(0) current_tiles = snake.get_tiles() moves += 1 renderer.clear(sdl2.ext.Color(0, 0, 0)) draw_grid(renderer) for x in range(len(current_tiles)): for y in range(len(current_tiles[x])): tile = current_tiles[x][y] if tile == 0: continue if tile == 1: continue if tile == 2: if game_over: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER) else: fill_tile(renderer, int(x), int(y), COLOR_SNAKE) if tile == 4: if game_over: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER) else: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD) if tile == 3: fill_circle(renderer, int(x), int(y), COLOR_FOOD) text = factory.from_text("Current score: " + str(snake.get_score()), fontmanager=font_manager) renderer.copy(text, dstrect=(0, 0, text.size[0], text.size[1])) text = factory.from_text("Move: " + str(moves), fontmanager=font_manager) renderer.copy(text, dstrect=(0, 14, text.size[0], text.size[1])) renderer.present() sdl2.SDL_Delay(33) return 0
def run(): lib.init() window = lib.Window('RLSnake', size=(window_width, window_height)) window.show() renderer = lib.Renderer(window) fontManager = sdl2.ext.FontManager(font_path = "assets/fonts/Roboto-Regular.ttf", size = 14) factory = sdl2.ext.SpriteFactory(renderer=renderer) text = factory.from_text("Current score: ",fontmanager=fontManager) snake = Snake(n_grid_x, n_grid_y) snake.set_visibility_range(args.visibility_range) snake.reset() network = ActorCriticNetwork(4, fc1_dims=args.neurons, fc2_dims=args.neurons) agent = TfAgent(network) agent.load_weights(args.model_path) autoplay = args.autoplay moves = 0 running = True game_over = False old_score = 0 current_tiles = snake.get_tiles() while running: events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break if event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: running = False break if event.key.keysym.sym == 112: autoplay = not autoplay if event.key.keysym.sym == 114: snake.reset() moves = 0 old_score = 0 game_over = False current_tiles = snake.get_tiles() break if not game_over: if not autoplay: if event.key.keysym.sym == sdl2.SDLK_SPACE: action = agent.get_action(snake.get_view_obs()) _, game_over, _ = snake.step(action) current_tiles = snake.get_tiles() moves += 1 if autoplay: action = agent.get_action(snake.get_view_obs()) _, game_over, _ = snake.step(action) current_tiles = snake.get_tiles() moves += 1 renderer.clear(sdl2.ext.Color(0, 0, 0)) draw_grid(renderer) for x in range(len(current_tiles)): for y in range(len(current_tiles[x])): tile = current_tiles[x][y] if tile == 0: continue if tile == 1: continue if tile == 2: if game_over: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER) else: if snake.get_score() > old_score: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_EATEN) else: fill_tile(renderer, int(x), int(y), COLOR_SNAKE) if tile == 4: if game_over: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_GAME_OVER) else: if snake.get_score() > old_score: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD_EATEN) else: fill_tile(renderer, int(x), int(y), COLOR_SNAKE_HEAD) if tile == 3: fill_circle(renderer, int(x), int(y), COLOR_FOOD) for tile in snake.get_current_view(): fill_tile(renderer, int(tile[0]), int(tile[1]), COLOR_VIEW_RANGE) if snake.get_score() > old_score: old_score = snake.get_score() text = factory.from_text("Current score: " + str(snake.get_score()), fontmanager=fontManager) renderer.copy(text, dstrect=(0, 0, text.size[0],text.size[1])) if autoplay: text = factory.from_text("Move: " + str(moves) + " / " + str(MAX_MOVES), fontmanager=fontManager) else: text = factory.from_text("Move: " + str(moves), fontmanager=fontManager) renderer.copy(text, dstrect=(0, 14, text.size[0],text.size[1])) renderer.present() sdl2.SDL_Delay(args.sleep) if autoplay and (game_over or moves >= MAX_MOVES): snake.reset() moves = 0 old_score = 0 game_over = False return 0
def run(self): prompt = CommandPrompt(self) print(">>> ", end='', flush=True) event = sdl2.SDL_Event() toc = 0 tic_toc_freq = sdl2.SDL_GetPerformanceFrequency() period = 1 excess = 0 remaining_cycles = 0 input_line = [] if self.has_sdl_audio: sdl2.SDL_PauseAudioDevice(self.audio_dev, 0) cpu_clock_rate = self.atari.color_clock_rate / 3 reasons = [Atari2600.StoppingReason.FRAME_DONE] current_input = self.input_stream[self.atari.frame_number] new_input = copy.deepcopy(current_input) while not self.done: # Timing. tic = toc toc = sdl2.timer.SDL_GetPerformanceCounter() elapsed = (toc - tic) / tic_toc_freq if elapsed > 1: # Too slow: reset counters. This may be caused by the program being # resumed or initialized. tic = toc elapsed = 0 elif elapsed < 1 / self.max_fps: # Too fast: throttle the simulation. This may be caused by # VSYNC is not working, for instance because the game window is hidden. sdl2.SDL_Delay(int(1000 * (1 / self.max_fps - elapsed))) toc = sdl2.timer.SDL_GetPerformanceCounter() elapsed = (toc - tic) / tic_toc_freq period = 0.95 * period + 0.05 * elapsed # Parse the SDL events. while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: self.done = True elif (event.type == sdl2.SDL_KEYUP or event.type == sdl2.SDL_KEYDOWN) and event.key.repeat == 0: if event.type == sdl2.SDL_KEYDOWN: if (event.key.keysym.sym == sdl2.SDLK_EQUALS or event.key.keysym.sym == sdl2.SDLK_KP_PLUS): self.speed = min(5., self.speed + 0.25) print(f"Speed increased to {self.speed}") continue elif event.key.keysym.sym == sdl2.SDLK_0: self.speed = 1. print(f"Speed reset to {self.speed}") continue elif event.key.keysym.sym == sdl2.SDLK_MINUS: self.speed = max(0., self.speed - 0.25) print(f"Speed decreased to {self.speed}") continue if self.switches_interface.update(event.key, new_input): continue if new_input.peripheral_type == Input.Type.JOYSTICK: if self.joysticks_interface.update( event.key, new_input): continue elif new_input.peripheral_type == Input.Type.PADDLE: if self.paddles_interface.update(event.key, new_input): continue elif event.type == sdl2.SDL_WINDOWEVENT: if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED: pass elif (event.type == sdl2.SDL_JOYDEVICEADDED or event.type == sdl2.SDL_CONTROLLERDEVICEADDED): self.joysticks_interface.associate_sdl_joystick( event.cdevice.which, verbose=self.verbosity > 0) elif (event.type == sdl2.SDL_JOYDEVICEREMOVED or event.type == sdl2.SDL_CONTROLLERDEVICEREMOVED): self.joysticks_interface.disassociate_sdl_device( event.cdevice.which) elif (event.type == sdl2.SDL_JOYAXISMOTION or event.type == sdl2.SDL_JOYHATMOTION or event.type == sdl2.SDL_JOYBUTTONUP or event.type == sdl2.SDL_JOYBUTTONDOWN): if new_input.peripheral_type == Input.Type.JOYSTICK: if self.joysticks_interface.update_sdl_joystick( event, new_input): continue elif new_input.peripheral_type == Input.Type.PADDLE: if self.paddles_interface.update_sdl_joystick( event, new_input): continue # Parse the console events. if os.name == 'nt': pass else: dr, _, _ = select.select([sys.stdin], [], [], 0.0) if sys.stdin in dr: input_line = sys.stdin.read(1024) prompt.onecmd(input_line) print(">>> ", end='', flush=True) # Simulate an amount of CPU cycles equivalent to the real time elapsed. # Limit this to roughly two video frames. if not self.paused: remaining_cycles += cpu_clock_rate * elapsed * self.speed remaining_cycles = int( min(remaining_cycles, cpu_clock_rate * 2 / 60)) while remaining_cycles > 0: # At the beginning of each new frame, adjust the input stream. if Atari2600.StoppingReason.FRAME_DONE in reasons: if new_input.peripheral_type == Input.Type.PADDLE: self.paddles_interface.integrate(new_input) # Feed the *current* input to the console. if new_input != current_input: self.input_stream[self.atari.frame_number] = new_input current_input = self.input_stream[self.atari.frame_number] self.atari.set_panel(current_input.panel) if current_input.peripheral_type == Input.Type.JOYSTICK: for k in range(2): self.atari.set_joystick( k, current_input.peripheral[k]) elif current_input.peripheral_type == Input.Type.PADDLE: for k in range(4): self.atari.set_paddle(k, current_input.peripheral[k]) new_input = copy.deepcopy(current_input) # Simulate. reasons, remaining_cycles = self.atari.cycle( remaining_cycles) # Copy the screen content to the video texture. frame = self.atari.get_last_frame() pixels = ctypes.c_void_p() pitch = ctypes.c_int() sdl2.SDL_LockTexture(self.texture, None, ctypes.byref(pixels), ctypes.byref(pitch)) ctypes.memmove(pixels, bytes(frame), frame.width * frame.height * 4) sdl2.SDL_UnlockTexture(self.texture) sdl2.SDL_SetRenderTarget(self.renderer, self.texture) # Render the video texture. bounds = [0, frame.height - 1] sdl2.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 0xff) sdl2.SDL_RenderClear(self.renderer) w = ctypes.c_int() h = ctypes.c_int() sdl2.SDL_GetWindowSize(self.screen, w, h) scale = min(w.value / (frame.width * self.aspect), h.value / (bounds[1] - bounds[0] + 1)) w_ = int(frame.width * self.aspect * scale) h_ = int((bounds[1] - bounds[0] + 1) * scale) dh_ = int(bounds[0] * scale) r = sdl2.SDL_Rect((int(w.value) - w_) // 2, (int(h.value) - h_) // 2 - dh_, w_, h_) sdl2.SDL_RenderCopy(self.renderer, self.texture, None, r) sdl2.SDL_RenderPresent(self.renderer) if self.has_sdl_audio: sdl2.SDL_PauseAudioDevice(self.audio_dev, 1)
def run(): sdl2.ext.init() factory = sdl2.ext.SpriteFactory(sdl2.ext.SOFTWARE) window = sdl2.ext.Window("Arkanoid v1", size=(800, 1000)) window.show() world = sdl2.ext.World() spriteRenderer = SoftwareRenderer(window) world.add_system(spriteRenderer) movement = MovementSyste(0, 0, 800, 1000) world.add_system(movement) collision = CollisionSystem(0, 0, 800, 1000) world.add_system(collision) sp_paddle = factory.from_color(WHITE, size=(100, 20)) paddle = Paddle(world, sp_paddle, 350, 980) collision.paddle = paddle sp_ball = factory.from_color(WHITE, size=(20, 20)) ball = Ball(world, sp_ball, 390, 960) collision.ball = ball brickList = [] for j in range(0, 25): poy = 52 + j*22 for i in range(0, 10): pox = 52 + i*42 sp_brick = factory.from_color(WHITE, size=(40,20)) brick = Brick(world, sp_brick, pox, poy) brickList.append(brick) collision.lis = brickList player = Player(1) collision.player = player img = factory.from_image(RESOURCES.get_path("koniecgry.jpg")) running = True flag = False while running: events = sdl2.ext.get_events() if player.zycia < 0: world.process() break for event in events: if event.type == sdl2.SDL_QUIT: running = False break if event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_RIGHT: paddle.velocity.vx = 3 if(ball.velocity.vx == 0 and ball.velocity.vy == 0 and ball.sprite.x < 800-62): ball.velocity.vx = 3 flag = True elif event.key.keysym.sym == sdl2.SDLK_LEFT: paddle.velocity.vx = -3 if(ball.velocity.vx == 0 and ball.velocity.vy == 0 and ball.sprite.x > 42): ball.velocity.vx = -3 flag = True if event.key.keysym.sym == sdl2.SDLK_SPACE: if ball.velocity.vx == 0 and ball.velocity.vy == 0: ball.velocity.vy = -3 tmp = random.randint(1, 2) if tmp == 1: ball.velocity.vx = -3 else: ball.velocity.vx = 3 elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym in (sdl2.SDLK_RIGHT, sdl2.SDLK_LEFT): paddle.velocity.vx = 0 if flag: ball.velocity.vx = 0 ball.velocity.vy = 0 flag = False sdl2.SDL_Delay(8) world.process() while running: ball = None #spriterenderer = factory.create_sprite_render_system(window) #spriterenderer.render(img) events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break return 0
def run(game_info): sdl2.ext.init() window = sdl2.ext.Window("The Pong Game", size=(800, 600)) window.show() factory = sdl2.ext.SpriteFactory(sdl2.ext.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)) sp_midline = factory.from_color(WHITE, size=(4, 600)) world = sdl2.ext.World() movement = MovementSystem(0, 0, 800, 600) spriterenderer = SoftwareRenderSystem(window) world.add_system(movement) world.add_system(spriterenderer) if game_info.num_players == 1: if game_info.difficulty == 'Easy': PADDLE_SPEED_AI = 3 BALL_SPEED = 3 elif game_info.difficulty == 'Medium': PADDLE_SPEED_AI = 5 BALL_SPEED = 4 # Eventually this else will handle a much better AI else: PADDLE_SPEED_AI = 3 BALL_SPEED = 3 aicontroller = TrackingAIController(0, 600, PADDLE_SPEED_AI) world.add_system(aicontroller) midline = Midline(world, sp_midline) ball = Ball(world, sp_ball, 390, 290) ball.velocity.vx = -BALL_SPEED aicontroller.ball = ball player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 780, 250, True) collision = CollisionSystem(0, 0, 800, 600, player1.playerdata, player2.playerdata) world.add_system(collision) collision.ball = ball 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_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_UP: player1.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdl2.SDLK_DOWN: player1.velocity.vy = PADDLE_SPEED elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN): player1.velocity.vy = 0 sdl2.SDL_Delay(10) world.process() else: BALL_SPEED = 3 ball = Ball(world, sp_ball, 390, 290) ball.velocity.vx = -BALL_SPEED player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 780, 250) collision = CollisionSystem(0, 0, 800, 600, player1.playerdata, player2.playerdata) world.add_system(collision) collision.ball = ball 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_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_w: player1.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdl2.SDLK_s: player1.velocity.vy = PADDLE_SPEED if event.key.keysym.sym == sdl2.SDLK_UP: player2.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdl2.SDLK_DOWN: player2.velocity.vy = PADDLE_SPEED elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym in (sdl2.SDLK_w, sdl2.SDLK_s): player1.velocity.vy = 0 if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN): player2.velocity.vy = 0 sdl2.SDL_Delay(10) world.process()
def run(game_info): sdl2.ext.init() window = sdl2.ext.Window("The Pong Game", size=(800, 600)) window.show() factory = sdl2.ext.SpriteFactory(sdl2.ext.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)) sp_midline = factory.from_color(WHITE, size=(4, 600)) world = sdl2.ext.World() movement = MovementSystem(0, 0, 800, 600) spriterenderer = SoftwareRenderSystem(window) dirname = os.path.dirname(__file__) filename = os.path.join(dirname, '../wrapper/Fonts/battle_star/Battle Star.ttf') fontmanager = sdl2.ext.FontManager(font_path=os.path.join(dirname, filename)) world.add_system(movement) world.add_system(spriterenderer) #world.add_componenttype(sdl2.ext.SpriteFactory) # add a midline for aesthetic midline = Midline(world, sp_midline) if game_info.num_players == 1: if game_info.difficulty == 'Easy': PADDLE_SPEED_AI = 3 BALL_SPEED = 3 elif game_info.difficulty == 'Medium': PADDLE_SPEED_AI = 5 BALL_SPEED = 4 # Eventually this else will handle a much better AI else: PADDLE_SPEED_AI = 3 BALL_SPEED = 3 aicontroller = TrackingAIController(0, 600, PADDLE_SPEED_AI) world.add_system(aicontroller) ball = Ball(world, sp_ball, 390, 290) ball.velocity.vx = -BALL_SPEED aicontroller.ball = ball player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 780, 250, True) displayscore1 = DisplayScore1(world, player1.playerdata.points, factory, fontmanager) displayscore2 = DisplayScore2(world, player2.playerdata.points, factory, fontmanager) collision = CollisionSystem(0, 0, 800, 600, player1, player2) world.add_system(collision) collision.ball = ball collision.displayscore1 = displayscore1 collision.displayscore2 = displayscore2 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_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_UP: player1.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdl2.SDLK_DOWN: player1.velocity.vy = PADDLE_SPEED elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN): player1.velocity.vy = 0 sdl2.SDL_Delay(10) world.process() else: BALL_SPEED = 3 ball = Ball(world, sp_ball, 390, 290) ball.velocity.vx = -BALL_SPEED player1 = Player(world, sp_paddle1, 0, 250) player2 = Player(world, sp_paddle2, 780, 250) displayscore1 = DisplayScore1(world, player1.playerdata.points, factory, fontmanager) displayscore2 = DisplayScore2(world, player2.playerdata.points, factory, fontmanager) collision = CollisionSystem(0, 0, 800, 600, player1, player2) world.add_system(collision) collision.ball = ball collision.displayscore1 = displayscore1 collision.displayscore2 = displayscore2 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_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_w: player1.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdl2.SDLK_s: player1.velocity.vy = PADDLE_SPEED if event.key.keysym.sym == sdl2.SDLK_UP: player2.velocity.vy = -PADDLE_SPEED elif event.key.keysym.sym == sdl2.SDLK_DOWN: player2.velocity.vy = PADDLE_SPEED elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym in (sdl2.SDLK_w, sdl2.SDLK_s): player1.velocity.vy = 0 if event.key.keysym.sym in (sdl2.SDLK_UP, sdl2.SDLK_DOWN): player2.velocity.vy = 0 sdl2.SDL_Delay(10) world.process()
def run(): sdl2.ext.init() window = sdl2.ext.Window("Arkanoid v1", size=(800, 1000)) window.show() world = sdl2.ext.World() spriterenderer = factory.create_sprite_render_system(window) spriteRenderer = SoftwareRenderer(window) world.add_system(spriteRenderer) movement = MovementSyste(0, 0, 800, 1000) world.add_system(movement) collision = CollisionSystem(0, 0, 800, 1000) world.add_system(collision) sp_paddle = factory.from_color(WHITE, size=(100, 20)) paddle = Paddle(world, sp_paddle, 350, 980) collision.paddle = paddle sp_ball = factory.from_color(WHITE, size=(20, 20)) ball = Ball(world, sp_ball, 390, 960) collision.ball = ball player = Player() collision.player = player img = factory.from_image(RESOURCES.get_path("koniecgry.jpg")) zycList = [] for i in range(0, player.zycia + 1): pox = 5 + i * 11 sp_hart = factory.from_color(RED, size=(10, 10)) hart = Brick(world, sp_hart, pox, 985) zycList.append(hart) collision.zyc = zycList running = True flag = False while running: events = sdl2.ext.get_events() if player.zycia < 0: world.process() break if collision.lis == [] and player.zycia >= 0 and player.lv < 8: player.lv += 1 brickList = [] for k in range(0, 1): for j in range(0, 3 * player.lv): poy = 220 - 22 * player.lv + j * 22 for i in range(0, 17): pox = 44 + i * 42 sp_brick = factory.from_color(WHITE, size=(40, 20)) brick = Brick(world, sp_brick, pox, poy) brickList.append(brick) collision.lis = brickList ball.sprite.x = paddle.sprite.x + 40 ball.sprite.y = paddle.sprite.y - 20 ball.velocity.vx = 0 ball.velocity.vy = 0 for event in events: if event.type == sdl2.SDL_QUIT: running = False world.process() break if event.type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_RIGHT: paddle.velocity.vx = 3 if (ball.velocity.vx == 0 and ball.velocity.vy == 0 and ball.sprite.x < 800 - 62): ball.velocity.vx = 3 flag = True elif event.key.keysym.sym == sdl2.SDLK_LEFT: paddle.velocity.vx = -3 if (ball.velocity.vx == 0 and ball.velocity.vy == 0 and ball.sprite.x > 42): ball.velocity.vx = -3 flag = True if event.key.keysym.sym == sdl2.SDLK_SPACE: if ball.velocity.vx == 0 and ball.velocity.vy == 0: ball.velocity.vy = -3 tmp = random.randint(1, 2) if tmp == 1: ball.velocity.vx = -3 else: ball.velocity.vx = 3 elif event.type == sdl2.SDL_KEYUP: if event.key.keysym.sym in (sdl2.SDLK_RIGHT, sdl2.SDLK_LEFT): paddle.velocity.vx = 0 if flag: ball.velocity.vx = 0 ball.velocity.vy = 0 flag = False sdl2.SDL_Delay(8) world.process() if running: spriterenderer.render(img) posy = 760 score = str(player.score) for i in range(0, len(score)): posx = 270 + i * 90 name = "" name = score[i] + ".jpg" img = factory.from_image(RESOURCES.get_path(name)) spriterenderer.render(img, posx, posy) while running: events = sdl2.ext.get_events() for event in events: if event.type == sdl2.SDL_QUIT: running = False break return 0
def main(): if len(sys.argv) < 3: print("Please provide player file name and player id") sys.exit(1) gameplay.state.my_player_id = None players_str = None with open(sys.argv[1], "r") as player_file: gameplay.state.my_player_id = int(sys.argv[2]) players_str = player_file.read() player_adds = players_str.split() num_players = len(player_adds) messaging = MessagingHandler() messaging.connect(player_adds, num_players, gameplay.state.my_player_id) running = True graphics.view.initView() gameplay.state.floor = Floor() gameplay.state.floor.genFloor(3, 0) gameplay.state.players = [] for i in range(num_players): new_player = Player(i, 200 + 200 * i, 350) gameplay.state.players.append(new_player) new_player.roomX = gameplay.state.floor.startingLocs[0][0] new_player.roomY = gameplay.state.floor.startingLocs[0][1] print("Starting room: %d %d" % (new_player.roomX, new_player.roomY)) gameplay.state.floor.board[new_player.roomX][new_player.roomY].simulation.add_object(new_player.collider) graphics.view.makeGameSubView() last_phys_time = sdl2.SDL_GetTicks() while running == True: frame_start = sdl2.SDL_GetTicks() input_events = sdl2.ext.get_events() game_events = [] for event in input_events: if event.type == sdl2.SDL_QUIT: running = False break else: if not ControlsState.should_process_input_event(event): continue ControlsState.update_state(event) player_event = gameplay.state.players[gameplay.state.my_player_id].processInputEvent(event) if player_event.params["code"] == "NONE": continue game_events.append(player_event) messaging.broadcast(player_event.serialize().encode("utf-8")) messages = messaging.get_messages() while messages.qsize() > 0: msg = messages.get() game_events.append(GameEvent.deserialize(msg.decode("utf-8"))) for event in game_events: if (event.params["type"] == "PLAYER"): gameplay.state.players[event.params["player_id"]].processPlayerEvent(event) if (event.params["type"] == "STATUS"): room = gameplay.state.floor.board[event.params["room_x"]["room_y"]] if event.params["kind"] == "bullet": print("UPDATING BULLET") obj = room.projectiles[event.params["id"]] obj.collider.pos.from_dict(event.params["pos"]) obj.collider.vel.from_dict(event.params["vel"]) curr_time = sdl2.SDL_GetTicks() delta = curr_time - last_phys_time last_phys_time = curr_time roomX = 0 for column in gameplay.state.floor.board: roomY = 0 for room in column: if room is not None: for p in [x for x in room.projectiles.keys() if x in gameplay.state.responsible_for]: b = room.projectiles[p] heartbeat_dict = { "type": "STATUS", "kind": "bullet", "player_id": b.id, "room_id": (roomX, roomY), "room_x": roomX, "room_y": roomY, "id": b.id, "pos": b.collider.pos.to_dict(), "vel": b.collider.pos.to_dict(), } print(heartbeat_dict) messaging.broadcast(player_event.serialize().encode("utf-8")) room.simulation.step(delta / 1000) roomY += 1 roomX += 1 graphics.view.render() frame_end = sdl2.SDL_GetTicks() remaining_time = (frame_start + FRAME_LENGTH) - frame_end if remaining_time > 0: sdl2.SDL_Delay(remaining_time) sdl2.ext.quit()
def main(): nodes = None edges = None if len(sys.argv) >= 2 and Path(sys.argv[1]).exists(): map_file = Path(sys.argv[1]) with map_file.open() as roadmap_input: nodes, edges = read_map(roadmap_input) # print(nodes, edges) else: nodes = [ Vector(100.0, 100.0), Vector(200.0, 200.0), Vector(300.0, 100.0), Vector(400, 200) ] edges = [[0, 1], [1, 2], [2, 0], [1, 3], [2, 3]] wps = [] for n in nodes: wps.append(WayPoint(n.x, n.y)) for e in edges: edge = WayPointEdge(wps[e[0]], wps[e[1]]) wps[e[0]].neighbors.append(edge) wps[e[1]].neighbors.append(edge) # print(Vector.distance(wps[e[0]].pos, wps[e[1]].pos)) rp = RoutePlanner(wps) start = Vector(0.0, 0.0) goal = Vector(500.0, 200.0) route_plan = rp.plan(start, goal) sdl2.sdl2_load( ctypes.util.find_library('SDL2'), # '/usr/local/lib/libSDL2.dylib' gfx_libpath=ctypes.util.find_library('SDL2_gfx')) sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) window = sdl2.SDL_CreateWindow(b"A* demonstration", 0, 0, WINDOW_W, WINDOW_H, sdl2.SDL_WINDOW_OPENGL) renderer = sdl2.SDL_CreateRenderer(window, -1, 0) mouse_x = ctypes.c_int() mouse_y = ctypes.c_int() fps_delay = 100 event = sdl2.SDL_Event() done = False while not done: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: # 'type' and 'timestamp' are common members for all SDL Event structs. event_type = event.common.type # event_timestamp = event.common.timestamp # print("Event : type=0x%s, timestamp=%s" % (event_type, event_timestamp) ) if event_type == sdl2.SDL_KEYDOWN: if event.key.keysym.sym == sdl2.SDLK_ESCAPE: done = True if event.key.keysym.sym == sdl2.SDLK_SPACE: route_plan = rp.plan(start, goal) sdl2.SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF) sdl2.SDL_RenderClear(renderer) mouse_state = sdl2.SDL_GetMouseState(ctypes.byref(mouse_x), ctypes.byref(mouse_y)) if mouse_state == (1 << (sdl2.SDL_BUTTON_LEFT - 1)): prev_x = start.x prev_y = start.y start.x = float(mouse_x.value) start.y = float(mouse_y.value) if start.x != prev_x or start.y != prev_y: route_plan = rp.plan(start, goal) elif mouse_state == (1 << (sdl2.SDL_BUTTON_RIGHT - 1)): prev_x = goal.x prev_y = goal.y goal.x = float(mouse_x.value) goal.y = float(mouse_y.value) if goal.x != prev_x or goal.y != prev_y: route_plan = rp.plan(start, goal) map_renderer.render_waypoints(renderer, wps) map_renderer.render_route_plan(renderer, start, goal, route_plan) sdl2.SDL_RenderPresent(renderer) sdl2.SDL_Delay(fps_delay) sdl2.SDL_DestroyRenderer(renderer) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit()
def run(): global shaderProgram global rot global projection global translation global view global lightVec if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return -1 window = sdl2.SDL_CreateWindow(b"OpenGL demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, windowwidth, windowheight, sdl2.SDL_WINDOW_OPENGL) if not window: print(sdl2.SDL_GetError()) return -1 video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK, video.SDL_GL_CONTEXT_PROFILE_CORE) context = sdl2.SDL_GL_CreateContext(window) # Setup GL shaders, data, etc. initialize() event = sdl2.SDL_Event() running = True # Initial position animated = 1 init_t = glm.vec3(0.0, 0.0, -4.0) rot = glm.mat4(1.0) rot = glm.rotate(rot, glm.radians(45), glm.vec3(0.0, 1.0, 0.0)) rot = glm.rotate(rot, glm.radians(20), glm.vec3(1.0, 0.0, 0.0)) rot = glm.rotate(rot, glm.radians(20), glm.vec3(0.0, 0.0, 1.0)) step = 0.5 translation = glm.mat4(1.0) translation = glm.translate(translation, init_t) projection = glm.perspective(glm.radians(45.0), windowwidth / windowheight, 1.0, 10.0) cameraPos = glm.vec3(0.0, 0.0, 1.0) cameraFront = glm.vec3(0.0, 0.0, -1.0) cameraUp = glm.vec3(0.0, 1.0, 0.0) view = glm.lookAt(cameraPos, cameraPos + cameraFront, cameraUp) while running: while sdl2.SDL_PollEvent(ctypes.byref(event)) != 0: if event.type == sdl2.SDL_QUIT: running = False elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_ESCAPE): running = False # Animation elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_s): if animated == 1: animated = 0 else: animated = 1 # Rotation elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_RIGHT): rot = glm.rotate(rot, glm.radians(step), glm.vec3(0.0, 0.0, 1.0)) elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_LEFT): rot = glm.rotate(rot, glm.radians(-step), glm.vec3(0.0, 0.0, 1.0)) elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_q): rot = glm.rotate(rot, glm.radians(step), glm.vec3(0.0, 1.0, 0.0)) elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_a): rot = glm.rotate(rot, glm.radians(-step), glm.vec3(0.0, 1.0, 0.0)) elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_UP): rot = glm.rotate(rot, glm.radians(step), glm.vec3(1.0, 0.0, 0.0)) elif (event.type == sdl2.SDL_KEYDOWN and event.key.keysym.sym == sdl2.SDLK_DOWN): rot = glm.rotate(rot, glm.radians(-step), glm.vec3(1.0, 0.0, 0.0)) render() if animated == 1: rot = glm.rotate(rot, glm.radians(step), glm.vec3(0.0, 1.0, 0.0)) sdl2.SDL_GL_SwapWindow(window) sdl2.SDL_Delay(10) sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
def run(): if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: print(sdl2.SDL_GetError()) return -1 window = sdl2.SDL_CreateWindow(b"OpenGL demo", sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, 800, 600, sdl2.SDL_WINDOW_OPENGL) if not window: print(sdl2.SDL_GetError()) return -1 # Force OpenGL 3.3 'core' context. # Must set *before* creating GL context! video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MAJOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_MINOR_VERSION, 3) video.SDL_GL_SetAttribute(video.SDL_GL_CONTEXT_PROFILE_MASK, video.SDL_GL_CONTEXT_PROFILE_CORE) context = sdl2.SDL_GL_CreateContext(window) quad = [ -0.5, -0.5, 0.0, 1.0, 0.0, 0.0, 0.5, -0.5, 0.0, 0.0, 1.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0, -0.5, 0.5, 0.0, 1.0, 1.0, 1.0 ] quad = numpy.array(quad, dtype=numpy.float32) indices = [0, 1, 2, 2, 3, 0] indices = numpy.array(indices, dtype=numpy.uint32) # Setup GL shaders, data, etc. vertex_shader = shaders.compileShader( """ #version 330 in vec3 position; in vec3 color; out vec3 newColor; void main() { gl_Position = vec4(position, 1.0f); newColor = color; } """, GL.GL_VERTEX_SHADER) fragment_shader = shaders.compileShader( """ #version 330 in vec3 newColor; out vec4 outColor; void main() { outColor = vec4(newColor, 1.0f); } """, GL.GL_FRAGMENT_SHADER) shaderProgram = shaders.compileProgram(vertex_shader, fragment_shader) GL.glUseProgram(shaderProgram) VAO = GL.glGenVertexArrays(1) GL.glBindVertexArray(VAO) # Need VBO for triangle vertices and colours VBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ARRAY_BUFFER, VBO) GL.glBufferData(GL.GL_ARRAY_BUFFER, 96, quad, GL.GL_STATIC_DRAW) EBO = GL.glGenBuffers(1) GL.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, EBO) GL.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL.GL_STATIC_DRAW) position = GL.glGetAttribLocation(shaderProgram, "position") GL.glVertexAttribPointer(position, 3, GL.GL_FLOAT, GL.GL_FALSE, 24, ctypes.c_void_p(0)) GL.glEnableVertexAttribArray(position) color = GL.glGetAttribLocation(shaderProgram, "color") GL.glVertexAttribPointer(color, 3, GL.GL_FLOAT, GL.GL_FALSE, 24, ctypes.c_void_p(12)) GL.glEnableVertexAttribArray(color) event = sdl2.SDL_Event() running = True GL.glClearColor(0, 0, 0, 1) while True: GL.glClear(GL.GL_COLOR_BUFFER_BIT) GL.glDrawElements(GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_INT, None) sdl2.SDL_GL_SwapWindow(window) sdl2.SDL_Delay(10) sdl2.SDL_GL_DeleteContext(context) sdl2.SDL_DestroyWindow(window) sdl2.SDL_Quit() return 0
import random import sdl2 import sdl2.ext from sdl2 import sdlgfx width = 800 height = 600 window = sdl2.ext.Window('window_title', size=(width, height)) window.show() surface = window.get_surface() pixels = sdl2.ext.pixels2d(surface) while True: skip = random.randint(2, 20) r = random.randint(0, 255) g = random.randint(0, 255) b = random.randint(0, 255) color = (r << 16) + (g << 8) + b for i in range(0, width, skip): pixels[i:i + 2, :] = color window.refresh() sdl2.SDL_Delay(5) # sdl2.SDL_Delay(3000) # sdl2.ext.quit()