Now Lesson 12 call lists with a twist



#!/usr/bin/env python
# pygame + PyOpenGL version of Nehe's OpenGL lesson12


#PyOpenGL attribution
# Paul Furber 2001 - m@verick.co.za

# Extended by Paul Mohr to lesson 12 NeHe in Python March 2009
# This is a set of cubes and uses call list

##NeHe attribution
## This code was created by Jeff Molofee '99 (ported to Linux/GLUT by Richard Campbell '99)
##
## If you've found this code useful, please let me know.
##
## Visit Jeff Molofee at www.demonews.com/hosted/nehe 
## (email Richard Campbell at ulmont@bellsouth.net)
##

import os, random
from string import split
from math import sin, cos
from OpenGL.GL import *
from OpenGL.GLU import *
import pygame, pygame.image, pygame.key
from pygame.locals import *


boxcol = [1.0,0.0,0.0],[1.0,0.50,0.0],[1.0,1.0,0.0],[0.0,1.0,0.0],[0.0,1.0,1.0] #[5][3]
topcol = [0.5,0.0,0.0],[0.5,0.25,0.0],[0.5,0.5,0.0],[0.0,0.5,0.0],[0.0,0.5,0.5]
cube = 0
top = 0
rangy = 40

points = [[[0.0 for x in range(3)] for x in range(rangy)] for x in range (rangy)]

textures = []
filter = 0 #Specifies the selection of images from a set of 4

xpos = 0.0
zpos = 0.0

xrot = 0.3
yrot = 0.0
zrot = 0.0
wiggle_count = 0

lookupdown = 0.0
walkbias = 0.0
walkbiasangle = 0.0

LightAmbient  = [ 0.5, 0.5, 0.5, 1.0]
LightDiffuse  = [ 1.0, 1.0, 1.0, 1.0]
LightPosition = [ 0.0, 0.0, 2.0, 1.0]

piover180 = 0.0174532925

def resize((width, height)):
    if height==0:
        height=1.0
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(45, float(width)/height, 0.1, 100.0)
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()

def init():
    global lookupdown, walkbias, walkbiasangle
    glEnable(GL_TEXTURE_2D)
    load_textures()
    glShadeModel(GL_SMOOTH)
    glClearColor(0.0, 0.0, 0.0, 0.0)
    glClearDepth(1.0)
    glEnable(GL_DEPTH_TEST)
    glDepthFunc(GL_LEQUAL)
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
    glLightfv( GL_LIGHT1, GL_AMBIENT, LightAmbient )
    glLightfv( GL_LIGHT1, GL_DIFFUSE, LightDiffuse )
    glLightfv( GL_LIGHT1, GL_POSITION, LightPosition )
    glEnable( GL_LIGHT1 )
    lookupdown    = 0.0
    walkbias      = 0.0
    walkbiasangle = 0.0
    glColor4f( 1.0, 1.0, 1.0, 0.5)
    xrot=0.0
    yrot=0.0
    zrot=0.0
    
def BuildList(): 
    global cube, top
    cube = glGenLists(2)
#;              # generate storage for 2 lists, and return a pointer to the first.
    glNewList(cube, GL_COMPILE)
    glBegin(GL_QUADS)
    glTexCoord2f(1.0, 1.0)
    glVertex3f(-1.0, -1.0, -1.0)
    glTexCoord2f(0.0, 1.0)
    glVertex3f( 1.0, -1.0, -1.0)
    glTexCoord2f(0.0, 0.0)
    glVertex3f( 1.0, -1.0,  1.0)
    glTexCoord2f(1.0, 0.0)
    glVertex3f(-1.0, -1.0,  1.0)
    glTexCoord2f(0.0, 0.0)
    glVertex3f(-1.0, -1.0,  1.0)
    glTexCoord2f(1.0, 0.0)
    glVertex3f( 1.0, -1.0,  1.0); # Bottom Right Of The Texture and Quad
    glTexCoord2f(1.0, 1.0); 
    glVertex3f( 1.0,  1.0,  1.0); # Top Right Of The Texture and Quad
    glTexCoord2f(0.0, 1.0); 
    glVertex3f(-1.0,  1.0,  1.0); # Top Left Of The Texture and Quad
    
    # Back Face
    glTexCoord2f(1.0, 0.0); 
    glVertex3f(-1.0, -1.0, -1.0); # Bottom Right Of The Texture and Quad
    glTexCoord2f(1.0, 1.0); 
    glVertex3f(-1.0,  1.0, -1.0); # Top Right Of The Texture and Quad
    glTexCoord2f(0.0, 1.0); 
    glVertex3f( 1.0,  1.0, -1.0); # Top Left Of The Texture and Quad
    glTexCoord2f(0.0, 0.0); 
    glVertex3f( 1.0, -1.0, -1.0); # Bottom Left Of The Texture and Quad
    
    # Right face
    glTexCoord2f(1.0, 0.0); 
    glVertex3f( 1.0, -1.0, -1.0); # Bottom Right Of The Texture and Quad
    glTexCoord2f(1.0, 1.0); 
    glVertex3f( 1.0,  1.0, -1.0); # Top Right Of The Texture and Quad
    glTexCoord2f(0.0, 1.0); 
    glVertex3f( 1.0,  1.0,  1.0); # Top Left Of The Texture and Quad
    glTexCoord2f(0.0, 0.0); 
    glVertex3f( 1.0, -1.0,  1.0); # Bottom Left Of The Texture and Quad
    
    # Left Face
    glTexCoord2f(0.0, 0.0); 
    glVertex3f(-1.0, -1.0, -1.0); # Bottom Left Of The Texture and Quad
    glTexCoord2f(1.0, 0.0); 
    glVertex3f(-1.0, -1.0,  1.0); # Bottom Right Of The Texture and Quad
    glTexCoord2f(1.0, 1.0); 
    glVertex3f(-1.0,  1.0,  1.0); # Top Right Of The Texture and Quad
    glTexCoord2f(0.0, 1.0); 
    glVertex3f(-1.0,  1.0, -1.0); # Top Left Of The Texture and Quad
    
    glEnd();
    glEndList();

    top = cube + 1;
    glNewList(top, GL_COMPILE);        # generate 2nd list (top of box).
    glBegin(GL_QUADS);
    glTexCoord2f(0.0, 1.0); 
    glVertex3f(-1.0,  1.0, -1.0); # Top Left Of The Texture and Quad
    glTexCoord2f(0.0, 0.0); 
    glVertex3f(-1.0,  1.0,  1.0); # Bottom Left Of The Texture and Quad
    glTexCoord2f(1.0, 0.0); 
    glVertex3f( 1.0,  1.0,  1.0); # Bottom Right Of The Texture and Quad
    glTexCoord2f(1.0, 1.0); 
    glVertex3f( 1.0,  1.0, -1.0); # Top Right Of The Texture and Quad
    glEnd();
    glEndList();
    
def fill_array():
 global points 
 float_x = 0.0
 float_y = 0.0
 while  float_x < (float) (rangy/5.1):
  while float_y < (float) (rangy/5.0):
       points[ int (float_x*5.0) ][ int (float_y*5.0) ][0] = float_x - 4.4;
       points[ int (float_x*5.0) ][ int (float_y*5.0) ][1] = float_y - 4.4;
       points[ int (float_x*5.0) ][ int (float_y*5.0) ][2] = \
   (float) (sin( ( (float_x*5.0*20.0)/360.0 ) * 3.14159 * 2.0 ));
       float_y += (float) (1.0/rangy)
  float_x +=  (float) (1.0/rangy)
  float_y = 0.0
 

def load_textures():
    global textures
    texturefile = os.path.join('data','texture1.png')
    textureSurface = pygame.image.load(texturefile)
    textureData = pygame.image.tostring(textureSurface, "RGBX", 1)
    texturefile = os.path.join('data','texture2.bmp')
    textureSurface2 = pygame.image.load(texturefile)
    textureData2 = pygame.image.tostring(textureSurface2, "RGBX", 1)
    texturefile = os.path.join('data','texture3.png')
    textureSurface3 = pygame.image.load(texturefile)
    textureData3 = pygame.image.tostring(textureSurface3, "RGBX", 1)
    texturefile = os.path.join('data','texture4.bmp')
    textureSurface = pygame.image.load(texturefile)
    textureData = pygame.image.tostring(textureSurface, "RGBX", 1)
    textures = glGenTextures(3)
    glBindTexture(GL_TEXTURE_2D, textures[0])
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, textureSurface.get_width(), textureSurface.get_height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, textureData )
    glBindTexture(GL_TEXTURE_2D, textures[1])
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, textureSurface2.get_width(), textureSurface2.get_height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, textureData2 )
    glBindTexture(GL_TEXTURE_2D, textures[2])
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, textureSurface3.get_width(), textureSurface3.get_height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, textureData3 )
    gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, textureSurface3.get_width(), textureSurface3.get_height(),
                       GL_RGBA, GL_UNSIGNED_BYTE, textureData3 );

def drawWave():
 global cube, top
 global xrot, zrot, yrot, wiggle_count 
 global points
 glPolygonMode( GL_BACK, GL_FILL )
 glPolygonMode( GL_FRONT, GL_LINE )
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 glLoadIdentity()
 glTranslatef(0.0,0.0,-12.0)
 glRotatef(xrot,1.0,0.0,0.0)
 glRotatef(yrot,0.0,1.0,0.0)
 glRotatef(zrot,0.0,0.0,1.0)
 glBindTexture(GL_TEXTURE_2D, textures[filter])
 glBegin(GL_QUADS)
 x=0
 while x < (rangy-1):
  y=0
  while y < (rangy-1):
   float_x = float(x)/44.0
   float_y = float(y)/44.0
   float_xb = float(x+1)/44.0
   float_yb = float(y+1)/44.0
   glTexCoord2f( float_x, float_y)
   glVertex3f( points[x][y][0], points[x][y][1], points[x][y][2] )
   glTexCoord2f( float_x, float_yb )
   glVertex3f( points[x][y+1][0], points[x][y+1][1], points[x][y+1][2] )
   glTexCoord2f( float_xb, float_yb )
   glVertex3f( points[x+1][y+1][0], points[x+1][y+1][1], points[x+1][y+1][2] )
   glTexCoord2f( float_xb, float_y )
   glVertex3f( points[x+1][y][0], points[x+1][y][1], points[x+1][y][2] )
   y+=1
  x+=1 
 glEnd()
 y=0
 x=0
 if( wiggle_count == 2 ):
  while  y < (rangy-1):
   hold=points[0][y][2]
   while x < (rangy-1):
    points[x][y][2] = points[x+1][y][2]
    x+=1
   x=0
   points[rangy-1][y][2]=hold
   y +=1
  wiggle_count = 0
 wiggle_count +=1
 xrot+=0.3
 yrot+=0.2
# zrot+=0.4
 
 yloop = 0
 while yloop < 6:
  xloop=0
  while xloop < 6:
       glLoadIdentity();
       glTranslatef(1.4+(((float)(xloop))*2.8)-(((float)(yloop))*1.4),((6.0-((float)(yloop)))*2.4)-7.0,-20.0);

       glRotatef(45.0 - (2.0*yloop)+xrot, 1.0, 0.0, 0.0);
       glRotatef(45.0 + yrot, 0.0, 1.0, 0.0);

       glColor3fv(boxcol[yloop-1]);     
       glCallList(cube);
     
       glColor3fv(topcol[yloop-1]);
       glCallList(top);
       xloop +=1
  yloop +=1
 return 0


def handle_keys(key):
    global xpos, zpos, yrot, filter
    global piover180, walkbiasangle, walkbias
    
    if key==K_ESCAPE:
        return 0

    if key==K_f:
        filter +=1
        if filter == 3:
            filter = 0
    if key==K_RIGHT:
        yrot -= 11.5
    if key==K_LEFT:
        yrot += 11.5
    if key==K_UP:
        xpos -= sin( yrot * piover180 ) * 0.3105
        zpos -= cos( yrot * piover180 ) * 0.3105
        if ( walkbiasangle >= 359.0 ):
            walkbiasangle = 0.0
        else:
            walkbiasangle += 10.0
        walkbias = sin( walkbiasangle * piover180 ) / 20.0
    if key==K_DOWN:
        xpos += sin( yrot * piover180 ) * 0.3105
        zpos += cos( yrot * piover180 ) * 0.3105
        if ( walkbiasangle <= 1.0 ):
            walkbiasangle = 359.0
        else:
            walkbiasangle -= 10.0
        walkbias = sin( walkbiasangle * piover180 ) / 20.0

    return 1

def main():
    global surface
    video_flags = OPENGL|DOUBLEBUF
    pygame.init()
    surface = pygame.display.set_mode((1024,768), video_flags)
    pygame.key.set_repeat(100,0)
    random.seed()
    resize((1024,768))
    init()
    fill_array() 
    BuildList()
    frames = 0
    done = 0
    ticks = pygame.time.get_ticks()
    while not done:
        while 1:
            event = pygame.event.poll()
            if event.type == NOEVENT:
                break
            if event.type == KEYDOWN:
                if handle_keys(event.key) == 0:
                    done = 1
            if event.type == QUIT:
                done = 1
        drawWave()
        pygame.display.flip()
        frames += 1
    print "fps:  %d" % ((frames*1000)/(pygame.time.get_ticks()-ticks))
if __name__ == '__main__': main()

I skipped the next few tutorials as they are not of interest to me. I will start putting up some of my personal code that handles multiple windows and OpenGL objects like graphs, lists, sliders, icons, 3D and other stuff.

2 comments:

jordaenne said...

Hi there Paul.
Good to see you having fun.
I work with youth all day. The players of video games but it is always nice to meet the creators of these guys.

Yes Canada is a beautiful in its white winter nakedness.When winter first comes I hate it for about a month and then I rather like it unless it is really extreme.

Does it snow in your part of the world?

Paul Mohr said...

It snows here, but currently there is very little snow. It is raining right now.

Automated Intelligence

Automated Intelligence
Auftrag der unendlichen LOL katzen