class Viewer:
def __init__(self, w, h):
self.lastTime = time.time()
self.windowWidth = w
self.windowHeight = h
self.initGLUT() # Initialize GLUT first! Depth test depends on window.
self.initGL()
self.camera = Camera(w, h)
self.camera.setProjection()
self.camera.setView()
self.buttonState = None
self.lastPosition = None
# Set up callbacks
glutDisplayFunc(self.redraw)
glutReshapeFunc(self.resize)
glutKeyboardFunc(self.keyfunc)
glutMouseFunc(self.mousefunc)
glutMotionFunc(self.motionfunc)
glutIdleFunc(self.idlefunc)
self.panelColors = []
for i in xrange(NUM_PANELS):
self.panelColors.append([0, 0, 0])
def keyfunc(self, key, x, y):
# global drawing_mode
glutPostRedisplay()
if key == 'a':
self.camera.x -= 1
if key == 'd':
self.camera.x += 1
if key == 'w':
self.camera.zoomIn()
if key == 's':
self.camera.zoomOut()
if key == chr(27) or key == 'q' or key == 'Q':
exit(0)
def mousefunc(self, button, state, x, y):
#self.camera.processMouse(button, state, x, y)
glutPostRedisplay()
def motionfunc(self, x, y):
#self.camera.processMotion(x, y)
glutPostRedisplay()
def idlefunc(self):
"""
currentTime = time.time()
elapsed = currentTime - self.lastTime
factor = 1 / math.pow(2, FALLOFF_RATE * elapsed)
def falloff(color):
color[0] *= factor
color[1] *= factor
color[2] *= factor
return color
map(lambda c: falloff(c), self.panelColors)
self.lastTime = currentTime
"""
glutPostRedisplay()
def redraw(self, clearColor=(0.2, 0.2, 0.2, 0), fill=False):
glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3])
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.camera.setView()
for i in xrange(NUM_PANELS):
startX = i
points = [[startX, 0, 0], [startX + 1, 0, 0], [startX + 1, 3, 0], [startX, 3, 0]]
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointer(3, GL_FLOAT, 0, points)
glColor3f(*self.panelColors[i])
glDrawArrays(GL_QUADS, 0, len(points))
glColor3f(0, 0.7, 0.7)
glDrawArrays(GL_LINE_LOOP, 0, len(points))
glDisableClientState(GL_VERTEX_ARRAY)
glutSwapBuffers()
def resize(self, w, h):
self.windowWidth = w
self.windowHeight = h
glViewport(0, 0, self.windowWidth, self.windowHeight)
self.camera.updateDimensions(w, h)
self.camera.setProjection()
glutPostRedisplay()
def initGL(self):
glShadeModel(GL_SMOOTH)
#glEnable(GL_CULL_FACE)
#glCullFace(GL_BACK)
glDisable(GL_DEPTH_TEST)
glEnable(GL_TEXTURE_2D)
glLineWidth(3)
glPointSize(12)
glDisable(GL_BLEND)
#glEnable(GL_BLEND)
#glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE)
glEnable(GL_POINT_SMOOTH)
glHint(GL_POINT_SMOOTH_HINT, GL_NICEST)
def initGLUT(self):
glutInit()
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(self.windowWidth, self.windowHeight)
glutInitWindowPosition(200, 200)
glutCreateWindow("Something")
def setPanelColor(self, num, r, g, b):
self.panelColors[num] = [r / 255, g / 255, b / 255]
def setPanelFromNote(self, note):
noteNum = note.pitch - LOWEST_NOTE
if noteNum < 0 or noteNum >= NUM_PANELS:
return
density = min(10, note.density)
if density > 5:
factor = 1 / math.exp(0.4 * (density - 5))
self.panelColors[noteNum] = [1, factor, factor]
else:
factor = 1 / math.exp(0.4 * (5 - density))
self.panelColors[noteNum] = [factor, factor, 1]
def main():
global camera, screen, proj
pygame.init()
pygame.mouse.set_cursor(*pygame.cursors.broken_x)
width, height = 1024,768
screen = pygame.display.set_mode((width, height), OPENGL|DOUBLEBUF)
# compute projection
aspectRatio = float(width)/float(height)
near = 0.01
far = 100.0
lens = 4.0 # "longer" lenses mean more telephoto
camera = Camera(lens, near, far, aspectRatio)
camera.moveBack(3)
clock = pygame.time.Clock()
init()
time = 0.0
while True:
clock.tick(30)
time += 0.01
# Event queued input
for event in pygame.event.get():
if event.type == QUIT:
return
if event.type == KEYUP and event.key == K_ESCAPE:
return
# Polling input is better for a real time camera
pressed = pygame.key.get_pressed()
# keys for zoom:
if pressed[K_z]:
camera.zoomIn(1.015)
if pressed[K_x]:
camera.zoomOut(1.015)
# arrow keys for movement:
movespeed = 0.05
if pressed[K_d] | pressed[K_RIGHT]:
camera.moveRight(movespeed)
if pressed[K_a] | pressed[K_LEFT]:
camera.moveRight(-movespeed)
if pressed[K_w] | pressed[K_UP]:
camera.moveBack(-movespeed)
if pressed[K_s] | pressed[K_DOWN]:
camera.moveBack(movespeed)
# mouse for rotation
rotspeed = 0.1
mousespeed = 0.5*rotspeed
x,y = pygame.mouse.get_pos()
if (x > 0) & (y > 0):
xDisplacement = x - 0.5*width
yDisplacement = y - 0.5*height
# normalize:
xNormed = xDisplacement/width
yNormed = -yDisplacement/height
newx = int(x - xDisplacement*mousespeed)
newy = int(y - yDisplacement*mousespeed)
if (newx != x) | (newy != y):
camera.pan(-xNormed * rotspeed)
camera.tilt(-yNormed * rotspeed)
pygame.mouse.set_pos((newx,newy))
display(time)
pygame.display.flip()
