init commit

Author: Sentdex

Chapter 7/gameobjects/__pycache__/util.cpython-34.pyc

@@ -0,0 +1,70 @@
+import pygame
+from pygame.locals import *
+from random import randint 
+
+class Star(object):
+
+    def __init__(self, x, y, speed):
+
+        self.x = x 
+        self.y = y 
+        self.speed = speed
+
+def run():
+
+    pygame.init()
+    screen = pygame.display.set_mode((640, 480), FULLSCREEN)
+
+    stars = []
+
+    # Add a few stars for the first frame 
+    for n in range(200):
+
+        x = float(randint(0, 639))
+        y = float(randint(0, 479))
+        speed = float(randint(10, 300))
+        stars.append( Star(x, y, speed) )
+
+    clock = pygame.time.Clock() 
+
+    white = (255, 255, 255) 
+
+    while True:
+
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                pygame.quit()
+                quit()
+            if event.type == KEYDOWN:
+                pygame.quit()
+                quit()
+
+        # Add a new star
+        y = float(randint(0, 479))
+        speed = float(randint(10, 300)) 
+        star = Star(640, y, speed)
+
+        stars.append(star)
+        time_passed = clock.tick()
+        time_passed_seconds = time_passed / 1000. 
+
+        screen.fill((0, 0, 0))
+
+        # Draw the stars 
+        for star in stars:
+
+            new_x = star.x - time_passed_seconds * star.speed 
+            pygame.draw.aaline(screen, white, (new_x, star.y), (star.x+1., star.y)) 
+            star.x = new_x
+
+        def on_screen(star):
+            return star.x > 0
+
+        # Remove stars that are no longer visible 
+        stars = list(filter(on_screen, stars))
+
+        pygame.display.update()
+
+
+if __name__ == "__main__":
+    run()

Chapter 8/8-1.py

@@ -0,0 +1,17 @@
+from math import sqrt 
+
+class Vector3(object):
+
+    def init (self, x, y, z):
+
+        self.x = x 
+        self.y = y 
+        self.z = z
+
+    def add (self, x, y, z):
+
+        return Vector3(self.x + x, self.y + y, self.z + z)
+
+    def get_magnitude(self):
+
+        return sqrt(self.x ** 2 + self.y ** 2 + self.z ** 2)

Chapter 8/8-2.py

@@ -0,0 +1,14 @@
+from gameobjects.vector3 import *
+
+A = Vector3(6, 8, 12)
+B = Vector3(10, 16, 12)
+
+print("A is", A)
+print("B is", B)
+print("Magnitude of A is", A.get_magnitude())
+print("A+B is", A+B)
+print("A-B is", A-B)
+
+
+print("A normalized is", A.get_normalized())
+print("A*2 is", A * 2)

Chapter 8/8-3.py

@@ -0,0 +1,14 @@
+from gameobjects.vector3 import *
+
+A = (-6, 2, 2) 
+B = (7, 5, 10)
+plasma_speed = 100 # meters per second
+
+AB = Vector3.from_points(A, B)
+print("Vector to droid is", AB)
+
+distance_to_target = AB.get_magnitude()
+print("Distance to droid is", distance_to_target, "meters")
+
+plasma_heading = AB.get_normalized()
+print("Heading is", plasma_heading)

Chapter 8/8-4.py

@@ -0,0 +1,2 @@
+def parallel_project(vector3):
+    return (vector3.x, vector3.y)

Chapter 8/8-5.py

@@ -0,0 +1,3 @@
+def perspective_project(vector3, d):
+    x, y, z = vector3
+    return (x * d/z, -y * d/z)

Chapter 8/8-6.py

@@ -0,0 +1,6 @@
+from math import tan
+
+def calculate_viewing_distance(fov, screen_width):
+
+    d = (screen_width/2.0) / tan(fov/2.0)
+    return d

Chapter 8/8-7.py

@@ -0,0 +1,149 @@
+import pygame
+from pygame.locals import *
+from gameobjects.vector3 import Vector3
+from math import *
+from random import randint
+
+SCREEN_SIZE =  (640, 480)
+CUBE_SIZE = 300
+
+def calculate_viewing_distance(fov, screen_width):
+    
+    d = (screen_width/2.0) / tan(fov/2.0)
+    return d
+    
+    
+def run():
+    
+    pygame.init()
+    screen = pygame.display.set_mode(SCREEN_SIZE, 0)
+    
+    default_font = pygame.font.get_default_font()
+    font = pygame.font.SysFont(default_font, 24)
+    
+    ball = pygame.image.load("ball.png").convert_alpha()
+    
+    # The 3D points
+    points = []
+    
+    fov = 90. # Field of view
+    viewing_distance = calculate_viewing_distance(radians(fov), SCREEN_SIZE[0])
+    
+    # Create a list of points along the edge of a cube
+    for x in range(0, CUBE_SIZE+1, 20):
+        edge_x = x == 0 or x == CUBE_SIZE
+        
+        for y in range(0, CUBE_SIZE+1, 20):
+            edge_y = y == 0 or y == CUBE_SIZE
+            
+            for z in range(0, CUBE_SIZE+1, 20):
+                edge_z = z == 0 or z == CUBE_SIZE
+                
+                if sum((edge_x, edge_y, edge_z)) >= 2:
+                    
+                    point_x = float(x) - CUBE_SIZE/2
+                    point_y = float(y) - CUBE_SIZE/2
+                    point_z = float(z) - CUBE_SIZE/2
+                    
+                    points.append(Vector3(point_x, point_y, point_z))
+    
+    # Sort points in z order    
+    def point_z(point):
+        return point.z
+    points.sort(key=point_z, reverse=True)
+    
+    center_x, center_y = SCREEN_SIZE
+    center_x /= 2
+    center_y /= 2
+    
+    ball_w, ball_h = ball.get_size()
+    ball_center_x = ball_w / 2
+    ball_center_y = ball_h / 2
+    
+    camera_position = Vector3(0.0, 0.0, -700.)
+    camera_speed = Vector3(300.0, 300.0, 300.0)
+    
+    clock = pygame.time.Clock()
+        
+    while True:        
+        
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                pygame.quit()
+                quit()
+        
+        screen.fill((0, 0, 0))
+        
+        pressed_keys = pygame.key.get_pressed()
+        
+        time_passed = clock.tick()
+        time_passed_seconds = time_passed / 1000.
+        
+        direction = Vector3()
+        if pressed_keys[K_LEFT]:
+            direction.x = -1.0
+        elif pressed_keys[K_RIGHT]:
+            direction.x = +1.0
+                        
+        if pressed_keys[K_UP]:
+            direction.y = +1.0
+        elif pressed_keys[K_DOWN]:
+            direction.y = -1.0
+        
+        if pressed_keys[K_q]:
+            direction.z = +1.0
+        elif pressed_keys[K_a]:
+            direction.z = -1.0
+            
+        if pressed_keys[K_w]:
+            fov = min(179., fov+1.)
+            w = SCREEN_SIZE[0]
+            viewing_distance = calculate_viewing_distance(radians(fov), w)
+        elif pressed_keys[K_s]:
+            fov = max(1., fov-1.)
+            w = SCREEN_SIZE[0]
+            viewing_distance = calculate_viewing_distance(radians(fov), w)
+        
+        camera_position += direction * camera_speed * time_passed_seconds       
+        
+        # Draw the 3D points
+        for point in points:
+            
+            x, y, z = point - camera_position
+            
+            if z > 0:
+                x =  x * viewing_distance / z
+                y = -y * viewing_distance / z
+                x += center_x
+                y += center_y
+                screen.blit(ball, (x-ball_center_x, y-ball_center_y))
+           
+        # Draw the field of view diagram
+        diagram_width = SCREEN_SIZE[0] / 4
+        col = (50, 255, 50)
+        diagram_points = []
+        diagram_points.append( (diagram_width/2, 100+viewing_distance/4) )
+        diagram_points.append( (0, 100) )
+        diagram_points.append( (diagram_width, 100) )
+        diagram_points.append( (diagram_width/2, 100+viewing_distance/4) )
+        diagram_points.append( (diagram_width/2, 100) )
+        pygame.draw.lines(screen, col, False, diagram_points, 2)        
+        
+        # Draw the text
+        white = (255, 255, 255)
+        cam_text = font.render("camera = "+str(camera_position), True, white)        
+        screen.blit(cam_text, (5, 5))
+        fov_text = font.render("field of view = %i"%int(fov), True, white)
+        screen.blit(fov_text, (5, 35))        
+        txt = "viewing distance = %.3f"%viewing_distance
+        d_text = font.render(txt, True, white)
+        screen.blit(d_text, (5, 65))
+            
+        pygame.display.update()
+        
+        
+if __name__ == "__main__":
+    run()
+    
+    
+