init commit

Author: Sentdex

Chapter 11/11-1.py

@@ -0,0 +1,3 @@
+from math import log, ceil
+def next_power_of_2(size):
+    return 2 ** ceil(log(size, 2))

Chapter 11/11-2.py

@@ -0,0 +1,114 @@
+from math import radians
+
+from OpenGL.GL import *
+from OpenGL.GLU import *
+
+import pygame
+from pygame.locals import *
+
+SCREEN_SIZE = (800, 600)
+
+def resize(width, height):
+
+    glViewport(0, 0, width, height)
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    gluPerspective(60.0, float(width)/height, .1, 1000.)
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+
+def init():
+
+    glEnable(GL_TEXTURE_2D)
+    glClearColor(1.0, 1.0, 1.0, 0.0)
+
+def run():
+
+    pygame.init()
+    screen = pygame.display.set_mode(SCREEN_SIZE, HWSURFACE|OPENGL|DOUBLEBUF)
+
+    resize(*SCREEN_SIZE)
+    init()
+
+    # Load the textures
+    texture_surface = pygame.image.load("sushitex.png")
+    # Retrieve the texture data
+    texture_data = pygame.image.tostring(texture_surface, 'RGB', True)
+
+    # Generate a texture id
+    texture_id = glGenTextures(1)
+    # Tell OpenGL we will be using this texture id for texture operations
+    glBindTexture(GL_TEXTURE_2D, texture_id)
+
+    # Tell OpenGL how to scale images
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR )
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR )
+
+    # Tell OpenGL that data is aligned to byte boundries
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
+
+    # Get the dimensions of the image
+    width, height = texture_surface.get_rect().size
+
+    # Upload the image to OpenGL
+    glTexImage2D( GL_TEXTURE_2D,
+                  0,
+                  3,
+                  width,
+                  height,
+                  0,
+                  GL_RGB,
+                  GL_UNSIGNED_BYTE,
+                  texture_data)
+
+
+    clock = pygame.time.Clock()
+
+    tex_rotation = 0.0
+
+    while True:
+
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                pygame.quit()
+                quit()
+
+
+        time_passed = clock.tick()
+        time_passed_seconds = time_passed / 1000.
+        tex_rotation += time_passed_seconds * 360.0 / 8.0
+
+
+        # Clear the screen (similar to fill)
+        glClear(GL_COLOR_BUFFER_BIT)
+
+        # Clear the model-view matrix
+        glLoadIdentity()
+
+        # Set the modelview matrix
+        glTranslatef(0.0, 0.0, -600.0)
+        glRotate(tex_rotation, 1, 0, 0)
+
+        # Draw a quad (4 vertices, 4 texture coords)
+        glBegin(GL_QUADS)
+
+        glTexCoord2f(0, 1)
+        glVertex3f(-300, 300, 0)
+
+        glTexCoord2f(1, 1)
+        glVertex3f(300, 300, 0)
+
+        glTexCoord2f(1, 0)
+        glVertex3f(300, -300, 0)
+
+        glTexCoord2f(0, 0)
+        glVertex3f(-300, -300, 0)
+
+        glEnd()
+
+        pygame.display.flip()
+
+    glDeleteTextures(texture_id)
+
+if __name__ == "__main__":
+    run()

Chapter 11/11-3.py

@@ -0,0 +1,32 @@
+from OpenGL.GL import *
+from OpenGL.GLU import *
+
+import pygame
+import os.path
+
+class Material(object):
+
+  def   init (self):
+
+        self.name = ""
+        self.texture_fname = None
+        self.texture_id = None
+
+class FaceGroup(object):
+
+  def   init (self):
+
+        self.tri_indices = []
+        self.material_name = ""
+
+class Model3D(object):
+
+  def   init (self):
+
+        self.vertices = []
+        self.tex_coords = []
+        self.normals = []
+        self.materials = {}
+        self.face_groups = []
+        # Display list id for quick rendering
+        self.display_list_id = None

Chapter 11/11-4.py

@@ -0,0 +1,79 @@
+    def read_obj(self, fname):
+
+        current_face_group = None
+
+        file_in = open(fname)
+
+        for line in file_in:
+
+            # Parse command and data from each line
+            words = line.split()
+            command = words[0]
+            data = words[1:]
+
+            if command == 'mtllib': # Material library
+
+                model_path = os.path.split(fname)[0]
+                mtllib_path = os.path.join( model_path, data[0] )                                
+                self.read_mtllib(mtllib_path)
+                
+            elif command == 'v': # Vertex
+                x, y, z = data
+                vertex = (float(x), float(y), float(z))
+                self.vertices.append(vertex)
+
+            elif command == 'vt': # Texture coordinate
+
+                s, t = data
+                tex_coord = (float(s), float(t))
+                self.tex_coords.append(tex_coord)
+
+            elif command == 'vn': # Normal
+
+                x, y, z = data
+                normal = (float(x), float(y), float(z))
+                self.normals.append(normal)
+
+            elif command == 'usemtl' : # Use material
+
+                current_face_group = FaceGroup()
+                current_face_group.material_name = data[0]
+                self.face_groups.append( current_face_group )
+
+            elif command == 'f':
+
+                assert len(data) ==  3, "Sorry, only triangles are supported"
+
+                # Parse indices from triples
+                for word in data:
+                    vi, ti, ni = word.split('/')
+                    indices = (int(vi) - 1, int(ti) - 1, int(ni) - 1)
+                    current_face_group.tri_indices.append(indices)
+
+
+        for material in self.materials.values():
+
+            model_path = os.path.split(fname)[0]
+            texture_path = os.path.join(model_path, material.texture_fname)
+            texture_surface = pygame.image.load(texture_path)
+            texture_data = pygame.image.tostring(texture_surface, 'RGB', True)
+
+            material.texture_id = glGenTextures(1)
+            glBindTexture(GL_TEXTURE_2D, material.texture_id)
+
+            glTexParameteri( GL_TEXTURE_2D,
+                             GL_TEXTURE_MAG_FILTER,
+                             GL_LINEAR)
+            glTexParameteri( GL_TEXTURE_2D,
+                             GL_TEXTURE_MIN_FILTER,
+                             GL_LINEAR_MIPMAP_LINEAR)
+
+            glPixelStorei(GL_UNPACK_ALIGNMENT,1)
+            width, height = texture_surface.get_rect().size
+            gluBuild2DMipmaps( GL_TEXTURE_2D,
+                               3,
+                               width,
+                               height,
+                               GL_RGB,
+                               GL_UNSIGNED_BYTE,
+                               texture_data)

Chapter 11/11-5.py

@@ -0,0 +1,16 @@
+    def read_mtllib(self, mtl_fname):
+
+        file_mtllib = open(mtl_fname)
+        for line in file_mtllib:
+
+            words = line.split()
+            command = words[0]
+            data = words[1:]
+
+            if command == 'newmtl':
+                material = Material()
+                material.name = data[0]
+                self.materials[data[0]] = material
+
+            elif command == 'map_Kd':
+                material.texture_fname = data[0]

Chapter 11/11-6.py

@@ -0,0 +1,28 @@
+    def draw(self):
+
+        vertices = self.vertices
+        tex_coords = self.tex_coords
+        normals = self.normals
+
+        for face_group in self.face_groups:
+        
+            material = self.materials[face_group.material_name]
+            glBindTexture(GL_TEXTURE_2D, material.texture_id)
+
+            glBegin(GL_TRIANGLES)
+            for vi, ti, ni in face_group.tri_indices:
+                glTexCoord2fv( tex_coords[ti] )
+                glNormal3fv( normals[ni] )
+                glVertex3fv( vertices[vi] )
+            glEnd()
+
+
+    def draw_quick(self):
+
+        if self.display_list_id is None:
+            self.display_list_id = glGenLists(1)
+            glNewList(self.display_list_id, GL_COMPILE)
+            self.draw()
+            glEndList()
+
+        glCallList(self.display_list_id)

Chapter 11/11-7.py

@@ -0,0 +1,25 @@
+    def __del__(self):
+
+        #Called when the model is cleaned up by Python
+        self.free_resources()
+
+    def free_resources(self):
+
+        # Delete the display list and textures
+        if self.display_list_id is not None:
+            glDeleteLists(self.display_list_id, 1)            
+            self.display_list_id = None
+
+        # Delete any textures we used
+        for material in self.materials.values():
+            if material.texture_id is not None:                
+                glDeleteTextures(material.texture_id)
+                
+        # Clear all the materials
+        self.materials.clear()        
+        
+        # Clear the geometry lists
+        del self.vertices[:]
+        del self.tex_coords[:]
+        del self.normals[:]        
+        del self.face_groups[:]   

Chapter 11/11-8.py

@@ -0,0 +1,93 @@
+from math import radians
+
+from OpenGL.GL import *
+from OpenGL.GLU import *
+
+import pygame
+from pygame.locals import *
+
+# Import the Model3D class
+import model3d
+
+SCREEN_SIZE = (800, 600)
+
+def resize(width, height):
+
+    glViewport(0, 0, width, height)
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity()
+    gluPerspective(60.0, float(width)/height, .1, 1000.)
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity()
+
+
+def init():
+
+    # Enable the GL features we will be using
+    glEnable(GL_DEPTH_TEST)
+    glEnable(GL_LIGHTING)
+    glEnable(GL_COLOR_MATERIAL)
+    glEnable(GL_TEXTURE_2D)
+    glEnable(GL_CULL_FACE)
+
+    glShadeModel(GL_SMOOTH)
+    glClearColor(1.0, 1.0, 1.0, 0.0) # white
+
+    # Set the material
+    glMaterial(GL_FRONT, GL_AMBIENT, (0.0, 0.0, 0.0, 1.0))
+    glMaterial(GL_FRONT, GL_DIFFUSE, (0.2, 0.2, 0.2, 1.0))
+    glMaterial(GL_FRONT, GL_SPECULAR, (1.0, 1.0, 1.0, 1.0))
+    glMaterial(GL_FRONT, GL_SHININESS, 10.0)
+
+    # Set light parameters
+    glLight(GL_LIGHT0, GL_AMBIENT, (0.0, 0.0, 0.0, 1.0))
+    glLight(GL_LIGHT0, GL_DIFFUSE, (0.4, 0.4, 0.4, 1.0))
+    glLight(GL_LIGHT0, GL_SPECULAR, (1.0, 1.0, 1.0, 1.0))
+
+    # Enable light 1 and set position
+    glEnable(GL_LIGHT0)
+    glLight(GL_LIGHT0, GL_POSITION,  (0, .5, 1, 0))
+
+
+def run():
+
+    pygame.init()
+    screen = pygame.display.set_mode(SCREEN_SIZE, HWSURFACE|OPENGL|DOUBLEBUF)
+
+    resize(*SCREEN_SIZE)
+    init()
+
+    clock = pygame.time.Clock()
+
+    # Read the model
+    tank_model = model3d.Model3D()
+    tank_model.read_obj('mytank.obj')
+
+    rotation = 0.0
+
+    while True:
+
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                pygame.quit()
+                quit()
+
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        time_passed = clock.tick()
+        time_passed_seconds = time_passed / 1000.0
+
+        glLoadIdentity()
+        glRotatef(15, 1, 0, 0)
+        glTranslatef(0.0, -1.5, -3.5)
+
+        rotation += time_passed_seconds * 45.0
+        glRotatef(rotation, 0, 1, 0)
+
+        tank_model.draw_quick()
+
+        pygame.display.flip()
+            
+
+if __name__ == "__main__":
+    run()