def build_flat_plane(self): scene = Scene(self.screen, self.camera_position, COLOUR_WHITE, self.scale) count = 1 for x in range(count): for y in range(count): s = int(self.screen.width / count) cube_material = Material( (0 + int(random.random() * 100), 150 + int(random.random() * 100), int(1 * random.random())), # (0,0,255), (0.5, 0.5, 0.5), (0.8, 0.8, 0.8), (0.5, 0.5, 0.5), 50 ) rectangle = Rectangle( Point(x * s - self.screen.width/2, -self.screen.height / 2, self.screen.distance + y * s), Point(x * s - self.screen.width/2, -self.screen.height / 2, self.screen.distance + (y+1) * s), Point((x+1) * s - self.screen.width/2, -self.screen.height / 2, self.screen.distance + y * s), cube_material ) scene.add_object(rectangle) light_position = Point(-self.screen.width/4,-self.screen.height/2 + 50, self.screen.width * 4 + self.screen.distance) light = Light(light_position) scene.add_light(light) return scene
def __init__(self, player, boss): self.p1 = player self.p2 = boss p1_status = Scene(max(len(self.p1.name), self.max_health) + 1, 3) p1_status.modify_background(self.p1.name) p2_status = Scene(max(len(self.p2.name), self.max_health) + 1, 3) p2_status.modify_background(self.p2.name) self.p1.health = HealthBar(self.max_health) p1_status.add_object(self.p1.health, 0, 2) self.p1.status_win = p1_status self.p1.thruster = Thruster(self.p1) self.p1.thruster.switch_direction() self.p1.thruster.set_color(curses.COLOR_CYAN) self.p2.health = HealthBar(self.max_health) p2_status.add_object(self.p2.health, 0, 2) self.p2.status_win = p2_status width, height = Scene.max_view(0, 7) width *= self.screens self.main_win = Scene(width, height) self.main_win.modify_background(self.generate_starfield(width, height))
def prepareScene(): scene = Scene() ring = material.load_object('ring') scene.add_object(ring, [1.0, 1.0, 1.0], [1.05, -1.0, 0.0, 0.0], [0.0, 0.0, 0.0]) cube = material.load_object('cube') scene.add_object(cube, [0.5, 0.5, 0.5], [0.0, 1.0, 0.0, 0.0], [0.2, 0.0, 0.6]) magnet = material.load_object('magnet') scene.add_object(magnet, [0.3, 0.3, 0.3], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0]) global tree model = scene.to_mesh() tree = BspTree.tree(model) global camera camera = Camera(model) camera.adjust_to_model() camera.see() camera.show_all()
from scene import Scene from camera import Camera from lights import * from objects import * from color import Color width, height = 800, 600 scene = Scene(Camera((0, -80, 20), 60), (80, 60), (width, height)) scene.add_light(Ambiant(intensity=0.2)) scene.add_light(Diffuse(-20, -40, 20, intensity=0.8)) scene.add_light(Diffuse(40, 40, 5, intensity=0.4)) scene.add_light(Specular(-20, -40, 20, intensity=0.6)) scene.add_object(Sphere(10, x=50, y=30, scale_z=1.5, color=Color(r=255))) scene.add_object(Sphere(3, z=20, scale_x=5, color=Color(g=255))) scene.add_object(Sphere(5, color=Color(r=255, b=255)).stretch('x', angle_y=60)) scene.add_object(Plane(z=-10, color=Color(255, 255, 255))) scene.add_object(Plane(z=80, color=Color(255, 255, 255))) scene.add_object(Plane(x=-80, rot_y=90, color=Color(b=255))) scene.add_object(Plane(x=80, rot_y=90, color=Color(b=255))) scene.add_object(Plane(y=100, rot_x=90, color=Color(r=255, g=255))) scene.add_object(Cylinder(5, x=-80, y=100, color=Color(b=255))) scene.add_object(Cylinder(5, x=80, y=100, color=Color(b=255))) scene.add_object(Cone(10, color=Color(r=128, g=128, b=128))) nb_lines_chunk = 50 dispatch = Dispatcher(61385, set(i for i in range(height) if i % nb_lines_chunk == 0), key_fmt='i')
white_light = Spotlight(np.array([3., 0., 1.5]), np.array([1., 1., 1.])) light1 = Spotlight(np.array([-2., -0.6, 1.4]), np.array([random(), random(), random()])) light2 = Spotlight(np.array([-0.6, 2., 1.4]), np.array([random(), random(), random()])) light3 = Spotlight(np.array([0.6, -2., 1.4]), np.array([random(), random(), random()])) light4 = Spotlight(np.array([2., 0.6, 1.4]), np.array([random(), random(), random()])) #white_light2 = Spotlight(np.array([0.,1.5,0.3]),np.array([1.,1.,1.])) #white_light3 = Spotlight(np.array([-1.,0.5,0.]),np.array([1.,1.,1.])) #red_light = Spotlight(np.array([0.,-1.5,1.]), np.array([1.,0.,0.])) #green_light = Spotlight(np.array([-1.74,0.75,1.]), np.array([0.,1.,0.])) #blue_light = Spotlight(np.array([1.74,0.75,1.]), np.array([0.,0.,1.])) this_scene.add_object(sphere1) this_scene.add_object(sphere2) this_scene.add_object(sphere3) this_scene.add_object(small_sphere1) this_scene.add_object(small_sphere2) this_scene.add_object(small_sphere3) this_scene.add_light(white_light) this_scene.add_light(light1) this_scene.add_light(light2) this_scene.add_light(light3) this_scene.add_light(light4) #this_scene.add_light(white_light2) #this_scene.add_light(white_light3) #this_scene.add_light(red_light) #this_scene.add_light(green_light)
from scene import Scene from sphere import Sphere from material import Material from light import Spotlight from rayon import raytracer_render from camera import Camera import numpy as np import matplotlib.pyplot as plt this_scene = Scene() some_material = Material( np.array([106., 102., 163.]) / 255, 0.5, 0.7, 0.1, 0.3, 0.4) red_material = Material( np.array([255., 151., 112.]) / 255, 0.8, 0.4, 0.2, 0.4, 0.7) light1 = Spotlight(np.array([1., 1., 0.]), np.array([252., 236., 201.]) / 255) #red_light = Spotlight(np.array([-1,2,1]),np.array([1,1,0])) #other_light = Spotlight(np.array([0,-1,1.5]),np.array([1,0,1])) blue_sphere = Sphere(np.array([0., 0., 3.]), 0.8, some_material) red_sphere = Sphere(np.array([0.4, 0.4, 1.8]), 0.1, red_material) this_scene.add_object(blue_sphere) this_scene.add_object(red_sphere) this_scene.add_light(light1) #this_scene.add_light(red_light) #this_scene.add_light(other_light) this_camera = Camera(1500, 1500, 2.2) plt.imsave('shadow exemple.png', raytracer_render(this_camera, this_scene))
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")
if __name__ == '__main__': # Select model to use model = Models.wolf02 model_details = MODEL_DETAILS[model] file_path = model_details[FileDetails.FILE_PATH] camera_pos = model_details[FileDetails.CAMERA_POS] light_source_pos = model_details[FileDetails.LIGHT_SOURCE_POS] camera_direction = [0, 0, -1] # Create model object obj = Object(*read_off_file(file_path).values()) scene = Scene(camera_pos, camera_direction, light_source_pos, (WIDTH, HEIGHT)) scene.add_object(obj) scene.simulate_model() DISPLAY_MATRIX = scene.display_coords # Render openGL function # main(render) # # Display some values # print(f"World Coords: {obj.vertices[Coords.WORLD][:3]}") # print(f"Camera Coords: {obj.vertices[Coords.CAMERA][:3]}") # print("---Face 1---") # for i, vertex_index in enumerate(obj.faces[Face.INDICES][0]): # print( # f"Vertex {i+1} World Coords: {obj.vertices[Coords.WORLD][vertex_index]}") # print( # f"Vertex {i+1} Camera Coords: {obj.vertices[Coords.CAMERA][vertex_index]}")
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) # Creates the terrain meshes and materials terrain_object = create_terrain() scene.add_object(terrain_object) # Game variables # A missile spawns every 2 seconds (this time gets smaller every missile, to # make the game harder with time) missile_spawn_time = 2 # Time until the next missile is shot missile_timer = missile_spawn_time # Storage for all missiles active in the game missiles = [] # Flashing effect Color flash_color = Color(0, 0, 0, 0) # Total time of the current flash total_flash_time = 0 # Time elapsed for the current flash flash_timer = 0 # 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() # 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 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 very dark blue (0, 0, 20) screen.fill((0, 0, 0)) # Spawn new missiles missile_timer -= delta_time if missile_timer < 0: # It's time to spawn a new missile # Reduce time until the next missile, but clamp it so we don't have more than # one missile every half a second missile_spawn_time -= 0.025 if missile_spawn_time < 0.5: missile_spawn_time = 0.5 # Reset the timer missile_timer = missile_spawn_time # Create a new missile new_missile = Missile() # Add the missile to the scene (for rendering) and on the missile storage, # for all other operations scene.add_object(new_missile) missiles.append(new_missile) # Animate missiles # We need the following to keep track of all missiles we'll have to destroy, # since we can't change the storage while we're iterating it missiles_to_destroy = [] for missile in missiles: # Update the missile missile.update(delta_time) # Check if the missile is close to the player plane (z < 0.1) if missile.position.z < 0.1: # Check if the missile is close enough to the player to hit him if missile.position.magnitude() < 0.25: # It has hit the player, flash the screen red for one second flash_color = Color(1, 0, 1, 1) total_flash_time = flash_timer = 1 # Destroy missile (remove it from the scene and add it to the destruction # list so we can remove it in a bit) missiles_to_destroy.append(missile) scene.remove_object(missile) # 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 # Check collisions for shot in shots: # Check each shot with each missile for missile in missiles: # Check the distance between the shot and the missile, it it is below # a threshould (in this case 0.5), destroy the missile and the shot distance = Vector3.distance(shot.position, missile.position) if distance < 0.5: # Add it to the missile destruction list, and remove it from the scene missiles_to_destroy.append(missile) scene.remove_object(missile) # Add it to the shot destruction list, and remove it from the scene shots_to_destroy.append(shot) scene.remove_object(shot) # Flash the screen cyan for 0.5 seconds flash_color = Color(0, 1, 1, 1) total_flash_time = flash_timer = 0.5 # Actually delete objects missiles = [x for x in missiles if x not in missiles_to_destroy] shots = [x for x in shots if x not in shots_to_destroy] # Render scene scene.render(screen) # Render screen flash if flash_timer > 0: flash_timer -= delta_time if flash_timer > 0: flash_color.a = flash_timer / total_flash_time # Render the full screen rectangle, using additive blend screen.fill(flash_color.premult_alpha().tuple3(), None, pygame.BLEND_RGB_ADD) # 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()
class Game: max_health = 10 ship_space = 15 screens = 3 def __init__(self, player, boss): self.p1 = player self.p2 = boss p1_status = Scene(max(len(self.p1.name), self.max_health) + 1, 3) p1_status.modify_background(self.p1.name) p2_status = Scene(max(len(self.p2.name), self.max_health) + 1, 3) p2_status.modify_background(self.p2.name) self.p1.health = HealthBar(self.max_health) p1_status.add_object(self.p1.health, 0, 2) self.p1.status_win = p1_status self.p1.thruster = Thruster(self.p1) self.p1.thruster.switch_direction() self.p1.thruster.set_color(curses.COLOR_CYAN) self.p2.health = HealthBar(self.max_health) p2_status.add_object(self.p2.health, 0, 2) self.p2.status_win = p2_status width, height = Scene.max_view(0, 7) width *= self.screens self.main_win = Scene(width, height) self.main_win.modify_background(self.generate_starfield(width, height)) def intro(self): self.midpoint_x = round( self.main_win.width * (self.screens - 0.5)/self.screens ) midpoint_y = self.main_win.height // 2 outline = Outline(self.p2) self.main_win.add_object( outline, self.midpoint_x + self.ship_space - 1, midpoint_y - self.p2.height // 2 - 1 ) outline = Outline(self.p1) self.main_win.add_object( outline, self.midpoint_x - self.ship_space - self.p1.width, midpoint_y - self.p1.height // 2 - 1 ) self.main_win.add_object( self.p2, self.midpoint_x + self.ship_space, midpoint_y - self.p2.height // 2 ) self.main_win.add_object( self.p1, 4, midpoint_y - self.p1.height // 2 ) self.main_win.add_object( self.p1.thruster, 2, midpoint_y + 1 ) self.main_win.display(0, 7) self.main_win.auto_refresh = False position = self.p1.scene.objects[self.p1.stacking_order] distance = self.midpoint_x - self.ship_space - position.x2 speed = 0.04 while distance > 0: self.main_win.move_relative(self.p1, x=1) self.main_win.move_relative(self.p1.thruster, x=1) self.p1.thruster.update() self.main_win.pan(x=1) self.main_win.refresh() time.sleep(speed) if distance == 40: self.main_win.hide(self.p1.thruster) if distance < 40: speed += 0.005 distance -= 1 msg = Alert('!!! WARNING !!!\nENEMY WEAPONS LOCKED') msg.show(self.main_win) self.main_win.refresh() time.sleep(3) msg.hide() self.main_win.refresh() def play(self): self.p1.status_win.display( curses.COLS // 2 - self.ship_space - self.max_health, 2 ) self.p2.status_win.display( curses.COLS // 2 + self.ship_space, 2 ) if self.p1.scene.objects[self.p1.stacking_order].x2 != self.midpoint_x - self.ship_space: self.main_win.move_to(self.p1, x=self.midpoint_x - self.ship_space - self.p1.width) self.main_win.pan(x=self.main_win.width - self.main_win.win_width) laser = Laser(self.p1, self.p2, self.main_win.height // 2) self.main_win.add_object(laser, laser.x1, laser.y) shield1 = Drawable(')') shield1.set_color(curses.COLOR_CYAN) shield1.set_attrs(curses.A_BOLD) self.main_win.add_object(shield1, laser.x1, laser.y) self.main_win.hide(shield1) shield2 = Drawable('(') shield2.set_color(curses.COLOR_CYAN) shield2.set_attrs(curses.A_BOLD) self.main_win.add_object(shield2, laser.x2, laser.y) self.main_win.hide(shield2) self.main_win.refresh() self.main_win.auto_refresh = True step = 0 while not self.p1.health.is_empty() and not self.p2.health.is_empty(): time.sleep(0.5) target1 = self.p1.get_target() target2 = self.p2.get_target() target = None successful = True if step < 5: target = self.p1 if not self.is_valid_target(target1): target1 = 0 elif not self.is_valid_target(target2) or target1 == target2: successful = False else: target = self.p2 if not self.is_valid_target(target2): target2 = 0 elif not self.is_valid_target(target1) or target1 == target2: successful = False self.p1.show_target(target2) self.p2.show_target(target1) direction = 1 if target is self.p1: direction = -1 self.main_win.show(laser) laser.start(direction) time.sleep(0.01) while laser.advance(): time.sleep(0.02) if not successful: if direction > 0: self.main_win.show(shield2) time.sleep(0.5) self.main_win.hide(shield2) else: self.main_win.show(shield1) time.sleep(0.5) self.main_win.hide(shield1) self.main_win.hide(laser) if successful: target.health.decrease() target.set_color(curses.COLOR_RED) if target.health.is_empty(): continue time.sleep(0.2) target.set_color(curses.COLOR_WHITE) step = (step + 1) % 10 explosion = Explosion(target) explosion.set_color(curses.COLOR_YELLOW) explosion.set_attrs(curses.A_BOLD) self.main_win.add_object(explosion, explosion.x, explosion.y) explosion.explode() self.winner = self.p2 if target is self.p2: self.winner = self.p1 def outro(self): if self.winner is self.p1: self.win_animation() else: self.lose_animation() def win_animation(self): ship_position = self.main_win.objects[self.p1.stacking_order].x1 distance = self.main_win.max_x - ship_position + 2 self.main_win.auto_refresh = False self.main_win.show(self.p1.thruster) self.p1.thruster.step = 1 speed = 0.25 while distance >= 0: self.main_win.move_relative(self.p1, x=1) self.p1.thruster.update() self.main_win.move_relative(self.p1.thruster, x=1) self.main_win.refresh() time.sleep(speed) speed -= 0.005 if speed < 0.04: speed = 0.04 distance -= 1 self.main_win.auto_refresh = True msg = Alert('!!! CONGRATULATIONS !!!\nTHE GUMMIES HAVE BEEN SAVED') msg.show(self.main_win) time.sleep(3) msg.hide() def lose_animation(self): msg = Alert('YOUR SHIP HAS BEEN DESTROYED') msg.show(self.main_win) time.sleep(5) msg.hide() def generate_starfield(self, width, height): starfield = '' stars = ['.', '*', '`', '.'] for y in range(0, height): for x in range(0, width): if random.randint(0, 30) == 0: starfield += random.choice(stars) else: starfield += ' ' starfield += '\n' return starfield.rstrip() @staticmethod def is_valid_target(target): return target in (1, 2, 3, 4, 5)
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(): """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 the cube mesh we're going to use for every single object cube_mesh = Mesh.create_cube((1, 1, 1)) # Spawn rate is one cube every 25 ms spawn_rate = 0.025 # Keep a timer for the cube spawn cube_spawn_time = spawn_rate # Storage for all the objects created this way falling_objects = [] # 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: # If ESC is pressed exit the application return # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 0)) # Update the cube spawn timer cube_spawn_time = cube_spawn_time - delta_time if cube_spawn_time < 0: # It's time to spawn a new cube cube_spawn_time = spawn_rate # Create a new cube, and add it to the scene new_cube = FallingCube(cube_mesh) scene.add_object(new_cube) # Add the new cube to the storage, so it can be updated falling_objects.append(new_cube) # Update the cubes for falling_object in falling_objects: falling_object.update(delta_time) # Is the cube fallen too far? if falling_object.position.y < -8: # Remove cube from scene scene.remove_object(falling_object) # Update the storage, so that all cubes that have fallen too far disappear falling_objects = [x for x in falling_objects if x.position.y > -8] # Render the 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()
rects = [] #rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects]) #rects = non_max_suppression(rects, probs=None, overlapThresh=0.65) objects = [] for contour in contours: obj = ImageObject(0, contour, frame) if obj.get_area() < 1000: continue if obj.get_area() > 30000: continue if obj.detect_human(): #print(f"HUMAN {i}") i += 1 objects.append(obj) for o in objects: scene.add_object(o) for i, o in scene.objects.items(): o.draw(frame) cv2.imshow('f', mask) cv2.imshow('fr', frame) k = cv2.waitKey(1) & 0xff if k == 27: break cap.release() cv2.destroyAllWindows()
class MainWindowHandler: def __init__(self, builder): self.builder = builder self.window = builder.get_object('main_window') self.object_store = builder.get_object('object_store') self.scene = Scene() self.output_buffer = builder.get_object('outputbuffer') self.press_start = None self.old_size = None self.rotation_ref = RotationRef.CENTER self.current_file = None self.clipping_method = LineClippingMethod.COHEN_SUTHERLAND self.pressed_keys = set() # 3D Tests obj = GraphicObject3D( vertices=[ Vec3( 0, 0, 0, ), Vec3( 0, 0, 1, ), Vec3( 1, 0, 1, ), Vec3( 1, 0, 0, ), Vec3( 0, 0, 0, ), Vec3( 0, 1, 0, ), Vec3( 1, 1, 0, ), Vec3( 1, 0, 0, ), Vec3( 0, 0, 0, ), Vec3( 0, 0, 1, ), Vec3( 0, 1, 1, ), Vec3( 0, 1, 0, ), Vec3( 0, 0, 0, ), Vec3( 0, 0, 1, ), Vec3( 0, 0, 1, ), Vec3( 0, 1, 1, ), Vec3( 1, 1, 1, ), Vec3( 1, 0, 1, ), Vec3( 0, 0, 1, ), Vec3( 0, 1, 1, ), Vec3( 0, 1, 1, ), Vec3( 1, 1, 1, ), Vec3( 1, 1, 0, ), Vec3( 0, 1, 0, ), ], name='hmmm', ) obj.rotate(30, 30, 30, reference=obj.centroid) self.add_object(obj) def log(self, msg: str): self.output_buffer.insert_at_cursor(f'{msg}\n') scrollwindow = self.builder.get_object('output_scrollwindow') adjustment = scrollwindow.get_vadjustment() adjustment.set_value(adjustment.get_upper()) def on_destroy(self, *args): self.window.get_application().quit() def on_resize(self, widget: Gtk.Widget, allocation: Gdk.Rectangle): if self.scene.window is None: w, h = allocation.width, allocation.height self.old_size = allocation self.scene.window = Window(Vec2(-w / 2, -h / 2), Vec2(w / 2, h / 2)) w_proportion = allocation.width / self.old_size.width h_proportion = allocation.height / self.old_size.height self.scene.window.max = Vec2(self.scene.window.max.x * w_proportion, self.scene.window.max.y * h_proportion) self.scene.window.min = Vec2(self.scene.window.min.x * w_proportion, self.scene.window.min.y * h_proportion) self.old_size = allocation self.scene.update_ndc() def viewport(self) -> Rect: widget = self.builder.get_object('drawing_area') return Rect(min=Vec2(0, 0), max=Vec2( widget.get_allocated_width(), widget.get_allocated_height(), )).with_margin(10) def on_draw(self, widget, cr): viewport = self.viewport() vp_matrix = viewport_matrix(viewport) cr.set_line_width(2.0) cr.paint() cr.set_source_rgb(0.8, 0.0, 0.0) for obj in self.scene.objs: clipped = obj.clipped(method=self.clipping_method) if clipped: clipped.draw(cr, vp_matrix) cr.set_source_rgb(0.4, 0.4, 0.4) viewport.draw(cr, vp_matrix) def on_new_object(self, widget): dialog = NewObjectDialog() response = dialog.dialog_window.run() if response == Gtk.ResponseType.OK: if dialog.new_object is not None: self.add_object(dialog.new_object) self.builder.get_object('drawing_area').queue_draw() else: self.log('ERROR: invalid object') def on_quit(self, widget): self.window.close() def on_about(self, widget): about_dialog = Gtk.AboutDialog( None, authors=['Arthur Bridi Guazzelli', 'João Paulo T. I. Z.'], version='1.5.0', program_name='Rudolph') about_dialog.run() about_dialog.close() def on_key_press(self, widget, event): ''' Returns: False if event can propagate, True otherwise. ''' DIRECTIONS = { Gdk.KEY_Up: Vec2(0, -10), Gdk.KEY_Down: Vec2(0, 10), Gdk.KEY_Left: Vec2(10, 0), Gdk.KEY_Right: Vec2(-10, 0), } self.pressed_keys |= {event.keyval} for key in self.pressed_keys: if key in DIRECTIONS: self.world_window.offset(DIRECTIONS[key]) self.window.queue_draw() return True def on_key_release(self, widget, event): ''' Returns: False if event can propagate, True otherwise. ''' self.pressed_keys -= {event.keyval} return False def on_button_press(self, widget, event): if BUTTON_EVENTS[event.button] == 'left': # register x, y self.press_start = Vec2(-event.x, event.y) self.dragging = True def on_motion(self, widget, event): def viewport_to_window(v: Vec2): viewport = self.viewport() return Vec2((v.x / viewport.width) * self.scene.window.width, (v.y / viewport.height) * self.scene.window.height) # register x, y # translate window if self.dragging: current = Vec2(-event.x, event.y) delta = viewport_to_window(current - self.press_start) window = self.scene.window m = rotation_matrix(window.angle) delta = delta @ m self.scene.translate_window(delta) self.press_start = current widget.queue_draw() def on_button_release(self, widget, event): if BUTTON_EVENTS[event.button] == 'left': self.dragging = False def on_scroll(self, widget, event): if event.direction == Gdk.ScrollDirection.UP: self.scene.zoom_window(0.5) elif event.direction == Gdk.ScrollDirection.DOWN: self.scene.zoom_window(2.0) widget.queue_draw() def on_press_navigation_button(self, widget): TRANSFORMATIONS = { 'nav-move-up': ('translate', Vec2(0, 10)), 'nav-move-down': ('translate', Vec2(0, -10)), 'nav-move-left': ('translate', Vec2(-10, 0)), 'nav-move-right': ('translate', Vec2(10, 0)), 'nav-rotate-left': ('rotate', -5), 'nav-rotate-right': ('rotate', 5), 'nav-zoom-in': ('scale', Vec2(1.1, 1.1)), 'nav-zoom-out': ('scale', Vec2(0.9, 0.9)), } op, *args = TRANSFORMATIONS[widget.get_name()] if op == 'translate': args[0] = (args[0] @ rotation_matrix(self.scene.window.angle)) for obj in self.selected_objs(): if op == 'translate': obj.translate(*args) elif op == 'scale': obj.scale(*args) elif op == 'rotate': try: abs_x = int(entry_text(self, 'rotation-ref-x')) abs_y = int(entry_text(self, 'rotation-ref-y')) except ValueError: abs_x = 0 abs_y = 0 ref = { RotationRef.CENTER: obj.centroid, RotationRef.ORIGIN: Vec2(0, 0), RotationRef.ABSOLUTE: Vec2(float(abs_x), float(abs_y)), }[self.rotation_ref] if isinstance(obj, GraphicObject3D): obj.rotate(args[0], 0, 0, ref) else: obj.rotate(*args, ref) obj.update_ndc(self.scene.window) self.window.queue_draw() def selected_objs(self): tree = self.builder.get_object('tree-displayfiles') store, rows = tree.get_selection().get_selected_rows() return (self.scene.objs[int(str(index))] for index in rows) def add_object(self, obj: GraphicObject): self.log(f'Object added: <{type(obj).__name__}>') self.scene.add_object(obj) self.add_to_treeview(obj) def add_to_treeview(self, obj: GraphicObject): self.object_store.append([obj.name, str(f'<{type(obj).__name__}>')]) def remove_selected_objects(self, widget): tree = self.builder.get_object('tree-displayfiles') store, paths = tree.get_selection().get_selected_rows() for path in reversed(paths): iter = store.get_iter(path) store.remove(iter) self.scene.remove_objects([int(str(path))]) self.window.queue_draw() def on_change_rotation_ref(self, widget: Gtk.RadioButton): for w in widget.get_group(): if w.get_active(): self.rotation_ref = { 'rotate-ref-obj-center': RotationRef.CENTER, 'rotate-ref-origin': RotationRef.ORIGIN, 'rotate-ref-abs': RotationRef.ABSOLUTE, }[w.get_name()] if w.get_name() == 'rotate-ref-abs': for _id in 'rotation-ref-x', 'rotation-ref-y': self.builder.get_object(_id).set_editable(True) def on_new_file(self, item): self.log('NEW FILE') old_window = self.scene.window self.scene = Scene(window=old_window) self.object_store.clear() self.current_file = None self.builder.get_object('drawing_area').queue_draw() def on_open_file(self, item): file_chooser = self.new_file_chooser(Gtk.FileChooserAction.OPEN) response = file_chooser.run() if response == Gtk.ResponseType.OK: path = file_chooser.get_filename() self.log(f'OPEN FILE: {path}') old_window = self.scene.window self.scene = load_scene(path) self.scene.window = old_window self.scene.update_ndc() self.object_store.clear() for obj in self.scene.objs: self.add_to_treeview(obj) self.current_file = path self.builder.get_object('drawing_area').queue_draw() file_chooser.destroy() def on_save_file(self, item): label = item.get_label() if label == 'gtk-save' and self.current_file is not None: self.save_scene() elif label == 'gtk-save-as' or self.current_file is None: file_chooser = self.new_file_chooser(Gtk.FileChooserAction.SAVE) response = file_chooser.run() if response == Gtk.ResponseType.OK: path = file_chooser.get_filename() self.log(path) self.save_scene() self.current_file = path file_chooser.destroy() def save_scene(self): save_scene(self.scene, self.current_file) self.log(f'SAVE FILE: {self.current_file}') def new_file_chooser(self, action): file_chooser = Gtk.FileChooserDialog( parent=self.window, action=action, buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK)) if action == Gtk.FileChooserAction.OPEN: file_chooser.title = 'Open file' elif action == Gtk.FileChooserAction.SAVE: file_chooser.title = 'Save file' file_chooser.set_current_name('untitled.obj') filter = Gtk.FileFilter() filter.set_name('CG OBJ') filter.add_pattern('*.obj') file_chooser.add_filter(filter) return file_chooser def on_clicked_rotate_window(self, widget: Gtk.Button): rotation_angle = int(entry_text(self, 'window-rot-entry')) self.scene.window.angle += rotation_angle for obj in self.scene.objs: obj.update_ndc(self.scene.window) self.log(f'Window rotated {rotation_angle} degrees') self.window.queue_draw() def on_change_clipping_method(self, widget: Gtk.ComboBoxText): METHODS = { 'Cohen Sutherland': LineClippingMethod.COHEN_SUTHERLAND, 'Liang Barsky': LineClippingMethod.LIANG_BARSKY, } self.clipping_method = METHODS[widget.get_active_text()] self.window.queue_draw()
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, 0) # Creates the terrain meshes and materials terrain_object = create_terrain() scene.add_object(terrain_object) # Timer delta_time = 0 prev_time = time.time() # 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 key_state = pygame.key.get_pressed() if key_state[pygame.K_ESCAPE]: return if key_state[pygame.K_d]: scene.camera.position = Vector3(scene.camera.position.x + 0.1, scene.camera.position.y, scene.camera.position.z) if key_state[pygame.K_a]: scene.camera.position = Vector3(scene.camera.position.x - 0.1, scene.camera.position.y, scene.camera.position.z) if key_state[pygame.K_w]: scene.camera.position = Vector3(scene.camera.position.x, scene.camera.position.y, scene.camera.position.z + 0.1) if key_state[pygame.K_s]: scene.camera.position = Vector3(scene.camera.position.x, scene.camera.position.y, scene.camera.position.z - 0.1) # Clears the screen with a very dark blue (0, 0, 20) screen.fill((0, 0, 20)) # 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()
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()
from scene import Scene from camera import Camera from lights import * from objects import * from color import Color width, height = 800, 600 scene = Scene(Camera((0, -80, 20), 60), (80, 60), (width, height)) scene.add_light(Ambiant(intensity=0.2)) scene.add_light(Diffuse(-20, -40, 20, intensity=0.8)) scene.add_light(Diffuse(40, 40, 5, intensity=0.4)) scene.add_light(Specular(-20, -40, 20, intensity=0.6)) scene.add_object(Sphere(10, x=50, y=30, scale_z=1.5, color=Color(r=255))) scene.add_object(Sphere(3, z=20, scale_x=5, color=Color(g=255))) scene.add_object(Sphere(5, color=Color(r=255, b=255)).stretch('x', angle_y=60)) scene.add_object(Plane(z=-10, color=Color(255, 255, 255))) scene.add_object(Plane(z=80, color=Color(255, 255, 255))) scene.add_object(Plane(x=-80, rot_y=90, color=Color(b=255))) scene.add_object(Plane(x=80, rot_y=90, color=Color(b=255))) scene.add_object(Plane(y=100, rot_x=90, color=Color(r=255, g=255))) scene.add_object(Cylinder(5, x=-80, y=100, color=Color(b=255))) scene.add_object(Cylinder(5, x=80, y=100, color=Color(b=255))) scene.add_object(Cone(10, color=Color(r=128, g=128, b=128))) nb_lines_chunk = 50 dispatch = Dispatcher(61385, set(i for i in range(height) if i % nb_lines_chunk == 0), key_fmt='i') dispatch.welcome = bytes(scene)
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(): # 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()