def __init__(self): if Missile.missile_mesh is None: Missile.missile_mesh = Missile.create_missile_mesh() Missile.missile_material = Material(Color(1, 0, 0, 1), "MissileMaterial") super().__init__("Missile") # Determine the spawn position. There's 33% chance it comes from the right, 33% that it # comes from behind the mountains, and 34% chance it comes from the left self.position = Vector3(0, random.uniform(0, 3), 12) r = random.uniform(0, 100) if r > 66: self.position.x = 7 self.rotation = Quaternion.AngleAxis(Vector3(0, 1, 0), math.radians(-90)) elif r > 33: self.position.y = -2 self.position.x = random.uniform(-4, 4) self.rotation = Quaternion.AngleAxis(Vector3(1, 0, 0), math.radians(-90)) else: self.position.x = -7 self.rotation = Quaternion.AngleAxis(Vector3(0, 1, 0), math.radians(90)) # Set the mesh and material of the missile self.mesh = Missile.missile_mesh self.material = Missile.missile_material # Sets the missile linear speed self.missile_speed = 2 # Sets the rotation speed (in radians per second) self.missile_rotation_speed = 0.75
def update(self, delta_time): """Animates the missile.""" # Moves missile based on its direction (the forward vector) velocity = self.forward() * self.missile_speed self.position += velocity * delta_time # Rotate missile towards the player - Figure out where it is pointing and # where do we want to point it current_dir = self.forward() desired_dir = (Vector3(0, 0, 0) - self.position).normalized() # Find the angle between these two directions dp = max(-1, min(1, dot_product(current_dir, desired_dir))) angle = math.acos(dp) # If the angle is larger than the ammount we can rotate a single frame, # given by the time elapsed and the missile rotation speed, we need to # clamp the value of the angle if abs(angle) > self.missile_rotation_speed * delta_time: angle = self.missile_rotation_speed * delta_time * math.copysign( 1, angle) # Figure out the rotation axis to point the missile towards the desired direction axis = cross_product(current_dir, desired_dir) axis.normalize() if (angle > 0.01): # Rotate the missile towards the player q = Quaternion.AngleAxis(axis, angle) self.rotation = q * self.rotation
def rotate_angle(self, angle): """Rotates the ball to a certain angle, parallel to the ground Args: angle (Vector3): Angle in degrees to snap the rotation to """ self.rotation = Quaternion.AngleAxis(Vector3(0, 0, 1), angle)
def update(self, delta_time): """Animates the cube, accelerating it with gravity and rotating it.""" self.velocity += GRAVITY * delta_time self.position.y += self.velocity * delta_time q = Quaternion.AngleAxis(self.rotation_axis, self.rotation_speed * delta_time) self.rotation = q * self.rotation
def update_behaviour(self, delta): # Do nothing but check for input if not active if not self.active: self.buffer_count += 1 * delta keys = pygame.key.get_pressed() if keys[self. ACTIVATE_BALL_KEY] and self.buffer_count >= self.INPUT_BUFFER: self.active = True return # Update the score display self.score_number_display.text = str( ScoreKeeper.current_score) + " (x" + str(self.combo) + ")" # Rotate over itself to show ball speed self.rotation = Quaternion.AngleAxis( self.up(), 20 * math.radians(delta * self.ball_speed)) * self.rotation # Keep it aligned with the "ground" self.position.z = 0 # Reset the list of unhandled collisions, since we're not even colliding if not self.my_collider.is_colliding: self.handled_collisions = [] # Move the ball self.position += self.ball_speed * self.direction_vector.normalized( ) * delta # If ball falls under the screen, reset it if self.position.y < self.LOWER_LIMIT: print("Ball Reset") ScoreKeeper.current_score += ScoreKeeper.SCORE_DEATH_PENALTY self.reset_ball()
def main(): """Main function, it implements the application loop""" # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window res_x = 640 res_y = 480 # Create a window and a display surface screen = pygame.display.set_mode((res_x, res_y)) # Create a scene scene = Scene("TestScene") scene.camera = Camera(False, res_x, res_y) # Moves the camera back 2 units scene.camera.position -= Vector3(0, 0, 2) # Create a sphere and place it in a scene, at position (0,0,0) obj1 = Object3d("TestObject") obj1.scale = Vector3(1, 1, 1) obj1.position = Vector3(0, 0, 0) obj1.mesh = Mesh.create_sphere((1, 1, 1), 12, 12) obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1") scene.add_object(obj1) # Specify the rotation of the object. It will rotate 15 degrees around the axis given, # every second angle = 0 axis = Vector3(0, 1, 0) axis.normalize() # Timer delta_time = 0 prev_time = time.time() pygame.mouse.set_visible(True) pygame.event.set_grab(False) # Game loop, runs forever while True: # Process OS events for event in pygame.event.get(): # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately return elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: return # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 0)) # Rotates the object, considering the time passed (not linked to frame rate) q = Quaternion.AngleAxis(axis, math.radians(angle) * delta_time) obj1.rotation = q * obj1.rotation scene.render(screen) # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time() #Variavel que vai guardar a tecla pressionada k = pygame.key.get_pressed() #Cada tecla tem a sua própria ação if (k[pygame.K_UP]): angle = 15 axis = Vector3(1, 0, 0) elif (k[pygame.K_DOWN]): angle = -15 axis = Vector3(1, 0, 0) elif (k[pygame.K_LEFT]): angle = 15 axis = Vector3(0, 1, 0) elif (k[pygame.K_RIGHT]): angle = -15 axis = Vector3(0, 1, 0) elif (k[pygame.K_PAGEUP]): angle = 15 axis = Vector3(0, 0, 1) elif (k[pygame.K_PAGEDOWN]): angle = -15 axis = Vector3(0, 0, 1) elif (k[pygame.K_w]): obj1.position.y = obj1.position.y + 0.001 elif (k[pygame.K_s]): obj1.position.y = obj1.position.y - 0.001 elif (k[pygame.K_a]): obj1.position.x = obj1.position.x - 0.001 elif (k[pygame.K_d]): obj1.position.x = obj1.position.x + 0.001 elif (k[pygame.K_q]): obj1.position.z = obj1.position.z + 0.001 elif (k[pygame.K_e]): obj1.position.z = obj1.position.z - 0.001 else: angle = 0
def main(): """Main function, it implements the application loop""" # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window res_x = 640 res_y = 480 # Create a window and a display surface screen = pygame.display.set_mode((res_x, res_y)) # Create a scene scene = Scene("TestScene") scene.camera = Camera(False, res_x, res_y) # Moves the camera back 2 units scene.camera.position -= Vector3(0, 0, 4) # Create a sphere and place it in a scene, at position (0,0,0) ''' obj1 = Object3d("TestObject") obj1.scale = Vector3(1, 1, 1) obj1.position = Vector3(0, 0, 0) obj1.mesh = Mesh.create_sphere((1, 1, 1), 12, 12) obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1") scene.add_object(obj1) ''' # puts name of file that you wanna load # if you dont want to load a file leave it as "" fileloaded = "teste2.obj" #if theres so file to be loaded if fileloaded == "": # Create a pyramid and place it in a scene, at position (0,0,0) obj1 = Object3d("TestObject") obj1.scale = Vector3(1, 1, 1) obj1.position = Vector3(0, 0, 0) obj1.mesh = Mesh.create_pyramid() obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1") scene.add_object(obj1) else: # Create a object chosen by the user and place it in a scene, at position (0,0,0) obj1 = Object3d("TestObject") obj1.scale = Vector3(1, 1, 1) obj1.position = Vector3(0, 0, 0) #function to enable objects to be loaded from terminal if len(sys.argv) == 2: print(True) obj1.mesh = Mesh.create_mesh(sys.argv[1]) #if nothing at the terminal just run normaly with the name of the file in code else: obj1.mesh = Mesh.create_mesh(fileloaded) # add object to viewer obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1") scene.add_object(obj1) # Specify the rotation of the object. It will rotate 15 degrees around the axis given, # every second angle = 50 axis = Vector3(1, 0.7, 0.2) axis.normalize() # Timer delta_time = 0 prev_time = time.time() pygame.mouse.set_visible(True) pygame.event.set_grab(False) # Game loop, runs forever while True: # Process OS events for event in pygame.event.get(): # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately return #if your pressing a key elif event.type == pygame.KEYDOWN: #exit the game if event.key == pygame.K_ESCAPE: return # rotate object in y axis if event.key == pygame.K_LEFT: axis = Vector3(0, 1, 0) if event.key == pygame.K_RIGHT: axis = Vector3(0, -1, 0) # rotate object in x axis if event.key == pygame.K_UP: axis = Vector3(1, 0, 0) if event.key == pygame.K_DOWN: axis = Vector3(-1, 0, 0) # rotate object in z axis if event.key == pygame.K_PAGEUP: axis = Vector3(0, 0, 1) if event.key == pygame.K_PAGEDOWN: axis = Vector3(0, 0, -1) #normalize axis axis.normalize() # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 0)) # Rotates the object, considering the time passed (not linked to frame rate) ax = (axis * math.radians(angle) * delta_time) q = Quaternion.AngleAxis(axis, math.radians(angle) * delta_time) #Object movement keys = pygame.key.get_pressed() # movementing object up down right and left if keys[pygame.K_LEFT]: obj1.rotation = q * obj1.rotation if keys[pygame.K_RIGHT]: obj1.rotation = q * obj1.rotation if keys[pygame.K_UP]: obj1.rotation = q * obj1.rotation if keys[pygame.K_DOWN]: obj1.rotation = q * obj1.rotation #functions to make the rotations work if keys[pygame.K_PAGEUP]: obj1.rotation = q * obj1.rotation if keys[pygame.K_PAGEDOWN]: obj1.rotation = q * obj1.rotation if keys[pygame.K_w]: obj1.position = Vector3(obj1.position.x, obj1.position.y + 0.006, obj1.position.z) if keys[pygame.K_s]: obj1.position = Vector3(obj1.position.x, obj1.position.y - 0.006, obj1.position.z) if keys[pygame.K_a]: obj1.position = Vector3(obj1.position.x - 0.006, obj1.position.y, obj1.position.z) if keys[pygame.K_d]: obj1.position = Vector3(obj1.position.x + 0.006, obj1.position.y, obj1.position.z) if keys[pygame.K_q]: obj1.position = Vector3(obj1.position.x, obj1.position.y, obj1.position.z - 0.006) if keys[pygame.K_e]: obj1.position = Vector3(obj1.position.x, obj1.position.y, obj1.position.z + 0.006) #rendering objects on to screen scene.render(screen) # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time()
def main(): """Main function, it implements the application loop""" # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window res_x = 1280 res_y = 720 # Create a window and a display surface screen = pygame.display.set_mode((res_x, res_y)) # Create a scene scene = Scene("TestScene") scene.camera = Camera(False, res_x, res_y) # Moves the camera back 2 units scene.camera.position -= Vector3(0, 0, 0) # Specify the rotation of the object. It will rotate 15 degrees around the axis given, every second axis = scene.camera.up() axis.normalize() # Timer delta_time = 0 prev_time = time.time() # Show mouse cursor pygame.mouse.set_visible(False) # Don't lock the mouse cursor to the game window pygame.event.set_grab(True) #Clean count to make a max nuber of cubes count = 0 #Number of cubes in scene while count < 72: #function to add 72 cubes in scene at random new_cube = RandomCube() scene.add_object(new_cube) count += 1 # Game loop, runs forever while True: # Process OS events for event in pygame.event.get(): # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately return elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: return axis.normalize() # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 20)) keys=pygame.key.get_pressed() # Confine the mouse to the center of the screen pygame.mouse.set_pos(res_x/2, res_y/2) # Get the mouse movement from the last frmae rel = pygame.mouse.get_rel() # Gets the rotation angle rotAngle = rel[0] * 4 if rel[0] != 0: # Rotates the object, considering the time passed (not linked to frame rate) q = Quaternion.AngleAxis(axis, math.radians(rotAngle) * delta_time) #camera rotation scene.camera.rotation = q * scene.camera.rotation ''' Movement Stuff''' #going forwards if keys[pygame.K_w]: scene.camera.position += scene.camera.forward() * delta_time * 4 #going backwards if keys[pygame.K_s]: scene.camera.position -= scene.camera.forward() * delta_time * 4 #going left if keys[pygame.K_a]: scene.camera.position -= scene.camera.right() * delta_time * 4 #going right if keys[pygame.K_d]: scene.camera.position += scene.camera.right() * delta_time * 4 # Render scene scene.render(screen) # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() #Limit fps to 144 while time.time() - prev_time < 0.00694: continue # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time()
def main(): # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window screenX = 640 screenY = 480 # Create a window and a display surface screen = pygame.display.set_mode((screenX, screenY)) # Create a scene scene = Scene("TesteCena") scene.camera = Camera(False, screenX, screenY) # Moves the camera back 2 units scene.camera.position -= Vector3(0, 0, 2) # Create a sphere and place it in a scene, at position (0,0,0) obj = Object3d("Object") obj.scale = Vector3(1, 1, 1) obj.position = Vector3(0, 0, 0) #Number of sides of the cilinder sides = 12 #Create a cilinder obj.mesh = Mesh.create_cylinder(sides, 1, 1, None) #Create a sphere #obj.mesh = Mesh.create_sphere((1, 1, 1), 12, 12) #Create a cube #obj.mesh = Mesh.create_cube((5, 5, 5)) obj.material = Material(Color(1, 0, 0, 1), "Material1") scene.add_object(obj) # Timer delta_time = 0 prev_time = time.time() pygame.mouse.set_visible(True) pygame.event.set_grab(False) # Game loop, runs forever while True: #Busca o evento events = pygame.event.get() key = pygame.key.get_pressed() ang = 20 #Quando é carregada a tecla W if key[pygame.K_w]: movement = Vector3(0, 1, 0) movement.normalize() obj.position = obj.position + movement * delta_time #Quando é carregada a tecla S if key[pygame.K_s]: movement = Vector3(0, -1, 0) movement.normalize() obj.position = obj.position + movement * delta_time #Quando é carregada a tecla A if key[pygame.K_a]: movement = Vector3(-1, 0, 0) movement.normalize() obj.position = obj.position + movement * delta_time #Quando é carregada a tecla D if key[pygame.K_d]: movement = Vector3(1, 0, 0) movement.normalize() obj.position = obj.position + movement * delta_time #Quando é carregada a tecla Q if key[pygame.K_q]: movement = Vector3(0, 0, 1) movement.normalize() obj.position = obj.position + movement * delta_time #Quando é carregada a tecla E if key[pygame.K_e]: movement = Vector3(0, 0, -1) movement.normalize() obj.position = obj.position + movement * delta_time #Quando é carregada a seta para a direita if key[pygame.K_RIGHT]: rot = Vector3(0, -1, 0) q = Quaternion.AngleAxis(rot.normalized(), math.radians(ang) * delta_time) obj.rotation = q * obj.rotation #Quando é carregada a seta para a esquerda if key[pygame.K_LEFT]: rot = Vector3(0, 1, 0) q = Quaternion.AngleAxis(rot.normalized(), math.radians(ang) * delta_time) obj.rotation = q * obj.rotation #Quando é carregada a seta para baixo if key[pygame.K_DOWN]: rot = Vector3(-1, 0, 0) q = Quaternion.AngleAxis(rot.normalized(), math.radians(ang) * delta_time) obj.rotation = q * obj.rotation #Quando é carregada a seta para cima if key[pygame.K_UP]: rot = Vector3(1, 0, 0) q = Quaternion.AngleAxis(rot.normalized(), math.radians(ang) * delta_time) obj.rotation = q * obj.rotation #Quando é carregada a tecla PgUp if key[pygame.K_PAGEUP]: rot = Vector3(0, 0, 1) q = Quaternion.AngleAxis(rot.normalized(), math.radians(ang) * delta_time) obj.rotation = q * obj.rotation #Quando é carregada a tecla PgDn if key[pygame.K_PAGEDOWN]: rot = Vector3(0, 0, -1) q = Quaternion.AngleAxis(rot.normalized(), math.radians(ang) * delta_time) obj.rotation = q * obj.rotation for event in events: #Quando é carregada a tecla ESC if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: exit() #Quando é carregado o botão para sair do programa if event.type == pygame.QUIT: exit() # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 0)) scene.render(screen) # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time()
def main(): """Main function, it implements the application loop""" # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window res_x = 1280 res_y = 720 # Create a window and a display surface screen = pygame.display.set_mode((res_x, res_y)) # Create a scene scene = Scene("TestScene") scene.camera = Camera(False, res_x, res_y) # Moves the camera back 2 units scene.camera.position -= Vector3(0, 0, 4) scene.camera.rotation = Quaternion.AngleAxis(Vector3(1, 0, 0), math.radians(-15)) # Creates the terrain meshes and materials terrain_meshes, terrain_materials = create_terrain() # Create container object for all the terrain sub-objects master_object = Object3d("TerrainObject") master_object.position = Vector3(0, -1, 0) scene.add_object(master_object) # Create the terrain objects and place it in a scene, at position (0,0,0) for _, (mesh, material) in enumerate(zip(terrain_meshes, terrain_materials)): obj = Object3d("TerrainObject") obj.scale = Vector3(1, 1, 1) obj.position = Vector3(0, 0, 0) obj.mesh = mesh obj.material = material master_object.add_child(obj) # Specify the rotation of the object. It will rotate 15 degrees around the axis given, # every second angle = 15 axis = Vector3(0, 1, 0) axis.normalize() # Timer delta_time = 0 prev_time = time.time() # Show mouse cursor pygame.mouse.set_visible(True) # Don't lock the mouse cursor to the game window pygame.event.set_grab(False) # Game loop, runs forever while True: # Process OS events for event in pygame.event.get(): # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately return elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: return # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 0)) # Rotates the object, considering the time passed (not linked to frame rate) q = Quaternion.AngleAxis(axis, math.radians(angle) * delta_time) master_object.rotation = q * master_object.rotation #Commented code serves to make benchmarks Mesh.stat_vertex_count = 0 Mesh.stat_transform_time = 0 Mesh.stat_render_time = 0 scene.render(screen) #Writes the benchmarks results print("Frame stats:") print(f"Vertex count = {Mesh.stat_vertex_count}") print(f"Transform time = {Mesh.stat_transform_time}s") print(f"Render time = {Mesh.stat_render_time}s") # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time() print(f"Frame time = {delta_time}s")
def __Main(): """ Main app loop """ # Pygame initialization pygame.init() pygame.freetype.init() pygame.display.set_caption("Breakout Breakdown Forever") window = pygame.display.set_mode( (HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION)) # Cameras game_camera = Camera(False, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION) menu_camera = Camera(True, HORIZONTAL_RESOLUTION, VERTICAL_RESOLUTION) # Tilt camera to desired view game_camera.position -= Vector3(0, 5, 20) angle = -15 game_camera.rotation = Quaternion.AngleAxis(Vector3(1, 0, 0), math.radians(angle)) game_scene.camera = game_camera menu_scene.camera = menu_camera # Correct paddle movement to match with mouse position on screen Paddle.V_RES = VERTICAL_RESOLUTION Paddle.H_RES = HORIZONTAL_RESOLUTION Paddle.CAMERA_CORRECTION = -game_camera.position.y + 7 # mat angle of -15 # Make and trigger level builder for the first stage level_builder = LevelBuilder("Level Builder") level_builder.make_level(game_scene) # Add it to the game scene game_scene.add_object(level_builder) # Create and add a menu object to the menu scene menu_scene.add_object(MainMenu("MENU")) # Fill the scene manager's scene list SceneManager.scene_list = [] SceneManager.scene_list.append(menu_scene) SceneManager.scene_list.append(game_scene) # Set up delta time delta_time = 0 prev_time = time.time() # Show mouse cursor pygame.mouse.set_visible(True) # Don't lock the mouse cursor to the game window pygame.event.set_grab(False) is_running = True SceneManager.switch_scene(0) # Main game loop while is_running: for event in pygame.event.get(): # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately is_running = False elif event.type == pygame.KEYDOWN: # If ESC is pressed exit the game if event.key == pygame.K_ESCAPE: is_running = False __current_scene = SceneManager.current_scene # Update the Display window.fill(__current_scene.BACKGROUND_COLOR) __current_scene.update_objects(delta_time) __current_scene.render(window) pygame.display.flip() # Updates delta time, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time()
def main(): """Main function, it implements the application loop""" # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window res_x = 640 res_y = 480 # Create a window and a display surface screen = pygame.display.set_mode((res_x, res_y)) # Create a scene scene = Scene("TestScene") scene.camera = Camera(False, res_x, res_y) # Moves the camera back 2 units scene.camera.position = Vector3(0, 0, -2) # Create a cube and place it in a scene, at position (0,0,0) obj1 = Object3d("TestObject") obj1.scale = Vector3(1, 1, 1) obj1.position = Vector3(0, 0, 2) obj1.mesh = Mesh.create_cube((1, 1, 1)) obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1") scene.add_object(obj1) # Create a second object, and add it as a child of the first object # When the first object rotates, this one will also mimic the transform obj2 = Object3d("ChildObject") obj2.position += Vector3(0, 0.75, 0) obj2.mesh = Mesh.create_cube((0.5, 0.5, 0.5)) obj2.material = Material(Color(0, 1, 0, 1), "TestMaterial2") obj1.add_child(obj2) # Specify the rotation of the object. It will rotate 15 degrees around the axis given, # every second angle = 15 axis = Vector3(1, 0.7, 0.2) axis.normalize() # Timer delta_time = 0 prev_time = time.time() pygame.mouse.set_visible(False) pygame.event.set_grab(True) # Game loop, runs forever while True: # Process OS events for event in pygame.event.get(): # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately return elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: # If ESC is pressed exit the application return # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 20)) # Rotates the object, considering the time passed (not linked to frame rate) q = Quaternion.AngleAxis(axis, math.radians(angle) * delta_time) obj1.rotation = q * obj1.rotation scene.render(screen) # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time()
def main(): # Initialize pygame, with the default parameters pygame.init() # Define the size/resolution of our window res_x = 1280 res_y = 720 # Create a window and a display surface screen = pygame.display.set_mode((res_x, res_y)) # Create a scene scene = Scene("TestScene") scene.camera = Camera(False, res_x, res_y) # Moves the camera back 2 units scene.camera.position -= Vector3(0, 0, 0) # Creates the terrain meshes and materials terrain_object = create_terrain() scene.add_object(terrain_object) # Minimum time between player shots shot_cooldown = 0.2 # Timer for the shot cooldown shot_timer = 0 # Storage for all the shots active in the game shots = [] # Timer delta_time = 0 prev_time = time.time() # Don't show mouse cursor pygame.mouse.set_visible(False) # Lock the mouse cursor to the game window pygame.event.set_grab(True) # Game loop, runs forever while True: #Busca o evento events = pygame.event.get() key = pygame.key.get_pressed() speed = 0.05 ang = 20 #Manter o rato no centro do ecrã displayCenter = [screen.get_size()[i] // 2 for i in range(2)] mouseMove = (0, 0) pygame.mouse.set_pos(displayCenter) #Buscar o movimento do rato e devolve (x, y) mouseMove = pygame.mouse.get_rel() #Código para movimentação da câmara a partir do movimento do rato rot = Vector3(mouseMove[1], mouseMove[0], 0) scene.camera.rotation *= Quaternion.AngleAxis( rot, math.radians(ang) * delta_time) #Para impedir que a câmara rode no eixo do Z scene.camera.rotation.z = 0 #Quando é carregada a tecla W if key[pygame.K_w]: movement = Vector3(0, 0, 1) movement.normalize() scene.camera.position += movement * delta_time + scene.camera.forward( ) * speed #Quando é carregada a tecla S if key[pygame.K_s]: movement = Vector3(0, 0, -1) movement.normalize() scene.camera.position += movement * delta_time - scene.camera.forward( ) * speed #Quando é carregada a tecla A if key[pygame.K_a]: movement = Vector3(-1, 0, 0) movement.normalize() scene.camera.position += movement * delta_time - scene.camera.right( ) * speed #Quando é carregada a tecla D if key[pygame.K_d]: movement = Vector3(1, 0, 0) movement.normalize() scene.camera.position += movement * delta_time + scene.camera.right( ) * speed # Process OS events for event in events: # Checks if the user closed the window if event.type == pygame.QUIT: # Exits the application immediately return elif event.type == pygame.KEYDOWN: # If ESC is pressed exit the application if event.key == pygame.K_ESCAPE: return elif event.type == pygame.MOUSEBUTTONDOWN: # If the user has the mouse button down if shot_timer <= 0: # We're not on cooldown, so we can shoot # Get the mouse position and convert it to NDC (normalized # device coordinates) mouse_pos = pygame.mouse.get_pos() mouse_pos = ((mouse_pos[0] / res_x) * 2 - 1, (mouse_pos[1] / res_y) * 2 - 1) # Create a shot shot = Shot() # Initialize the position and direction of the shot, based on the # mouse position on the screen. For this, we request the scene camera the # ray corresponding to the mouse position shot.position, shot.direction = scene.camera.ray_from_ndc( mouse_pos) # Add the shot to the scene (for rendering) and on the shot storage, for # all other operations scene.add_object(shot) shots.append(shot) # Reset the cooldown shot_timer = shot_cooldown # Clears the screen with a black (0, 0, 0) screen.fill((0, 0, 0)) # Animate shots # We need the following to keep track of all shots we'll have to destroy, # since we can't change the storage while we're iterating it shots_to_destroy = [] for shot in shots: # Update the shot shot.update(delta_time) # Check if the shot is too far away, and add it to the destruction list, # besides removing it from the scene if shot.position.z > 12: # Destroy shot shots_to_destroy.append(shot) scene.remove_object(shot) # Update shot cooldown shot_timer -= delta_time # Actually delete objects shots = [x for x in shots if x not in shots_to_destroy] # Render scene scene.render(screen) # Swaps the back and front buffer, effectively displaying what we rendered pygame.display.flip() # Updates the timer, so we we know how long has it been since the last frame delta_time = time.time() - prev_time prev_time = time.time()