import sys, time, math, random
from pyglet.gl import *

window = pyglet.window.Window()
keys = pyglet.window.key.KeyStateHandler()
window.push_handlers(keys)

glEnable(GL_DEPTH_TEST)

class Building:
    def __init__(self, pos, size, texturefile):
        self.pos = pos
        self.size = size
        self.texture = pyglet.image.load(texturefile).get_mipmapped_texture()
        p0 = [pos[0]-size[0]/2.0, pos[1], pos[2]-size[2]/2.0]
        p1 = [pos[0]+size[0]/2.0, pos[1]+size[1], pos[2]+size[2]/2.0]
        verts = [p0[0], p0[1], p0[2],
             p1[0], p0[1], p0[2],
             p1[0], p1[1], p0[2],
             p0[0], p1[1], p0[2],
             p1[0], p0[1], p0[2],
             p1[0], p0[1], p1[2],
             p1[0], p1[1], p1[2],
             p1[0], p1[1], p0[2],
             p1[0], p0[1], p1[2],
             p0[0], p0[1], p1[2],
             p0[0], p1[1], p1[2],
             p1[0], p1[1], p1[2],
             p0[0], p0[1], p1[2],
             p0[0], p0[1], p0[2],
             p0[0], p1[1], p0[2],
             p0[0], p1[1], p1[2],
             p0[0], p1[1], p0[2],
             p0[0], p1[1], p1[2],
             p1[0], p1[1], p1[2],
             p1[0], p1[1], p0[2],
            ]
        texc = [0,0, size[0]/10.0,0, size[0]/10.0,size[1]/10.0, 0,size[1]/10.0] * 4 + [0,0, 0,0, 0,0, 0,0]
        self.vlist = pyglet.graphics.vertex_list(20, ('v3f', verts), ('t2f', texc))
    def draw(self):
        glEnable(GL_TEXTURE_2D)
        glBindTexture(GL_TEXTURE_2D, self.texture.id)
        self.vlist.draw(GL_QUADS)

class Ground:
    def __init__(self, pos, size, texturefile):
        self.pos = pos
        self.size = size
        self.texture = pyglet.image.load(texturefile).get_mipmapped_texture()
        self.vlist = pyglet.graphics.vertex_list(4,
                            ('v3f', [-size,0,-size,  size,0,-size,
                                     size,0,size,  -size,0,size]),
                            ('t2f', [0,0, 0,size/1.0,
                                     size/1.0,size/1.0,  size/1.0,0])
                            )
    def draw(self):
        glEnable(GL_TEXTURE_2D)
        glBindTexture(GL_TEXTURE_2D, self.texture.id)
        self.vlist.draw(GL_QUADS)
        glDisable(GL_TEXTURE_2D)

class Camera:
    def __init__(self):
        self.pos = [0, 5, 80]
        self.heading = 0
    def apply(self):
        glRotatef(-self.heading, 0, 1, 0)
        glTranslatef(-self.pos[0], -self.pos[1], -self.pos[2])
    def moveLeft(self, dist):
        self.pos[0] += dist * (-math.sin(math.radians(self.heading+90)))
        self.pos[2] += dist * (-math.cos(math.radians(self.heading+90)))
    def moveRight(self, dist):
        self.pos[0] += dist * (-math.sin(math.radians(self.heading-90)))
        self.pos[2] += dist * (-math.cos(math.radians(self.heading-90)))
    def moveUp(self, dist):
        self.pos[1] += dist
    def moveDown(self, dist):
        self.pos[1] -= dist
    def moveForward(self, dist):
        self.pos[0] += dist * (-math.sin(math.radians(self.heading)))
        self.pos[2] += dist * (-math.cos(math.radians(self.heading)))
    def moveBack(self, dist):
        self.pos[0] -= dist * (-math.sin(math.radians(self.heading)))
        self.pos[2] -= dist * (-math.cos(math.radians(self.heading)))
    def turnLeft(self, angle):
        self.heading += angle
    def turnRight(self, angle):
        self.heading -= angle

objects = [ Ground([0,0,0], 100, 'cobblestones.jpg') ]
for i in range(-40,60,20):
    for j in range(-40,60,20):
        objects.append(Building([i,0,j],[10,random.randint(2,7)*10,10],'building.jpg'))

camera = Camera()

@window.event
def on_draw():
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#Left eye
    glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    glFrustum((-7.5+0.1)/15, (7.5+0.1)/15, -7.5/15, 7.5/15, 1, 1000)
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()
    glTranslatef(0.1, 0.0, -15.0)
    drawWorld()

# Right eye
    glClear(GL_DEPTH_BUFFER_BIT)
    glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    glFrustum((-7.5-0.1)/15, (7.5-0.1)/15, -7.5/15, 7.5/15, 1, 1000)
    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity()
    glTranslatef(-0.1, 0.0, -15.0)
    drawWorld()
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE)


def drawWorld():
    global camera
    glLoadIdentity()
    camera.apply()
    for o in objects:
        o.draw()


def update(dt):
    global camera
    if keys[pyglet.window.key.W]:
        camera.moveForward(20*dt)
    if keys[pyglet.window.key.S]:
        camera.moveBack(20*dt)
    if keys[pyglet.window.key.A]:
        camera.turnLeft(90*dt)
    if keys[pyglet.window.key.D]:
        camera.turnRight(90*dt)
    if keys[pyglet.window.key.UP]:
        camera.moveUp(20*dt)
    if keys[pyglet.window.key.DOWN]:
        camera.moveDown(20*dt)

pyglet.clock.schedule_interval(update,1/60.0)
pyglet.app.run()