#!/usr/bin/env python

# -*- coding: utf-8 -*-

# Copyright (C) 2012-2013 Hector Martin "marcan" <hector@marcansoft.com>

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 2 or version 3.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

import OpenGL.GL as gl

from OpenGL import platform as gl_platform

import OpenGL.GL.shaders as shaders

import OpenGL.GLUT as glut

import ctypes

import os

import sys

from blitzloop.backend.common import *

class Display(BaseDisplay):

KEYMAP = {

b"\x1b": "KEY_ESCAPE",

b"\r": "KEY_ENTER",

glut.GLUT_KEY_UP: "KEY_UP",

glut.GLUT_KEY_DOWN: "KEY_DOWN",

glut.GLUT_KEY_LEFT: "KEY_LEFT",

glut.GLUT_KEY_RIGHT: "KEY_RIGHT",

}

def __init__(self, width=640, height=480, fullscreen=False, aspect=None):

self.gl = gl

glut.glutInit(sys.argv)

glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)

glut.glutInitWindowPosition(0, 0)

glut.glutCreateWindow(b"BlitzLoop Karaoke")

if not fullscreen:

glut.glutReshapeWindow(width, height)

else:

glut.glutSetCursor(glut.GLUT_CURSOR_NONE)

BaseDisplay.__init__(self, width, height, fullscreen, aspect)

self._on_reshape(width, height)

if fullscreen:

self.saved_size = (width, height)

glut.glutFullScreen()

glut.glutDisplayFunc(self._render)

glut.glutIdleFunc(self._render)

glut.glutReshapeFunc(self._on_reshape)

glut.glutKeyboardFunc(self._on_keyboard)

glut.glutSpecialFunc(self._on_keyboard)

try:

glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS)

print("Using FreeGLUT mainloop return feature")

except:

pass

self._initialize()

def toggle_fullscreen(self):

if self.fullscreen:

glut.glutReshapeWindow(*self.saved_size)

else:

self.saved_size = self.win_width, self.win_height

glut.glutFullScreen()

self.fullscreen = not self.fullscreen

def _on_reshape(self, width, height):

self.win_width = width

self.win_height = height

self.gl.glViewport(0, 0, width, height)

self.set_aspect(self.aspect)

def _on_keyboard(self, key, x, y):

if self.kbd_handler:

if key in self.KEYMAP:

key = self.KEYMAP[key]

elif isinstance(key, bytes):

key = key.decode("ascii").lower()

else:

return

self.kbd_handler(key)

elif key == b"\033":

self.queue_exit()

def _render(self):

try:

BaseDisplay._render(self)

except StopIteration:

self.do_exit()

try:

glut.glutLeaveMainLoop()

except:

os._exit(0)

except BaseException as e:

sys.excepthook(*sys.exc_info())

self.swap_buffers()

if self.should_exit:

self.do_exit()

try:

glut.glutLeaveMainLoop()

except:

os._exit(0)

def swap_buffers(self):

glut.glutSwapBuffers()

def main_loop(self):

glut.glutMainLoop()

print("GLUT main loop exited")

self.do_exit() # This may be called twice, exit handler only runs on first call

def get_proc_address(self, s):

proc = glut.glutGetProcAddress(s)

if not proc and os.name == "nt":

# glutGetProcAddress is documented to only look up GLUT functions.

# Since it uses dlsym on Linux, it happens to also work for GL

# functions, but that is not the behavior on Windows where a dynamic

# lookup needs to specify explicitly what module to search in.

proc = ctypes.cast(getattr(gl_platform.PLATFORM.GL, s.decode('ascii')), ctypes.c_void_p).value

return proc

if __name__ == "__main__":

fs_red = """

void main() {

gl_FragColor = vec4(1.0, 0.0, 0.0, 0.0);

}

"""

vs_null = """

void main() {

gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

}

"""

d = Display()

shader = shaders.compileProgram(

shaders.compileShader(vs_null, gl.GL_VERTEX_SHADER),

shaders.compileShader(fs_red, gl.GL_FRAGMENT_SHADER),

)

def render():

while True:

gl.glClearColor(0,0,0,1)

gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)

with shader:

gl.glBegin(gl.GL_TRIANGLES)

gl.glVertex2f(0,0)

gl.glVertex2f(1,0)

gl.glVertex2f(0,1)

gl.glEnd()

yield None

d.set_render_gen(render)

d.main_loop()