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 __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 visualizeGraph(V1, G1, C1, S1):
#Assign
global V
global G
global C
global S
V = V1
G = G1
C = C1
S = S1
#Take Log
S = numpy.log(S + 1)
#Init Glut
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(1024, 1024)
glut.glutCreateWindow("Visualize (GLUT)")
glut.glutDisplayFunc(on_display)
glut.glutKeyboardFunc(on_keyboard)
glut.glutReshapeFunc(on_reshape)
#Lookat
gluLookAt(0, 12, 0, 0, 0, 0, 0, 0, 1)
#Idle function
glut.glutIdleFunc(on_idle)
glut.glutFullScreen()
glut.glutMainLoop()
def __init__(self):
"""
Initialize and create GLUT window
"""
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH)
glut.glutCreateWindow("OpenGL")
glut.glutFullScreen()
gl.glEnable(gl.GL_TEXTURE_2D)
gl.glDisable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
gl.glEnableClientState(gl.GL_VERTEX_ARRAY)
# Modify matrices for screen size
width = glut.glutGet(glut.GLUT_SCREEN_WIDTH)
height = glut.glutGet(glut.GLUT_SCREEN_HEIGHT)
gl.glViewport(0, 0, width, height)
gl.glMatrixMode(gl.GL_PROJECTION)
aspect = width / height
gl.glOrtho(-aspect, aspect, 1, -1, -1, 1)
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glLoadIdentity()
def visualizeGraph(V1,G1,C1,S1):
#Assign
global V
global G
global C
global S
V = V1
G = G1
C = C1
S = S1
#Take Log
S = numpy.log(S + 1)
#Init Glut
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowSize(1024,1024)
glut.glutCreateWindow("Visualize (GLUT)")
glut.glutDisplayFunc(on_display)
glut.glutKeyboardFunc(on_keyboard)
glut.glutReshapeFunc(on_reshape);
#Lookat
gluLookAt(0,12,0, 0,0,0, 0,0,1);
#Idle function
glut.glutIdleFunc(on_idle)
glut.glutFullScreen()
glut.glutMainLoop()
def setFullscreen(self, state):
'''
If **state** is True, the set_fullscreen() method requests the window
manager to place the window in the fullscreen state. If **state** is
False the set_fullscreen() method requests the window manager to toggle
off the fullscreen state for the window. Note that in any case, you
shouldn't not assume the window state is definitely set afterward,
because other entities (e.g. the user or window manager) could
fullscreen/unfullscreen it again, and not all window managers honor
requests to fullscreen windows.
:param bool state:
Fullscreen state to be set.
'''
if self._fullscreen == state:
return
if state == True:
glut.glutSetWindow( self._id )
self._saved_width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
self._saved_height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
self._saved_x = glut.glutGet(glut.GLUT_WINDOW_X)
self._saved_y = glut.glutGet(glut.GLUT_WINDOW_Y)
self._fullscreen = True
glut.glutFullScreen()
else:
self._fullscreen = False
glut.glutSetWindow( self._id )
glut.glutReshapeWindow(self._saved_width, self._saved_height)
glut.glutPositionWindow( self._saved_x, self._saved_y )
glut.glutSetWindowTitle( self._title )
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 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 set_fullscreen(self, state):
''' Exit fullscreen mode '''
self._fullscreen = state
if state:
self._saved_width = glut.glutGet(glut.GLUT_WINDOW_WIDTH)
self._saved_height = glut.glutGet(glut.GLUT_WINDOW_HEIGHT)
glut.glutFullScreen()
else:
glut.glutReshapeWindow(self._saved_width, self._saved_height)
def _vispy_set_fullscreen(self, fullscreen):
old_val = self._fullscreen
self._fullscreen = bool(fullscreen)
if old_val != self._fullscreen:
if self._fullscreen:
self._old_size = self._vispy_get_size()
glut.glutFullScreen()
else:
self._vispy_set_size(*self._old_size)
def init(self):
# Initialize display
global global_init
if not global_init:
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH | glut.GLUT_ALPHA)
glut.glutCreateWindow(b'fbmatrix')
global_init = True
if self.preview or self.raw:
glut.glutReshapeWindow(512, 512)
elif self.emulate:
glut.glutReshapeWindow(1024, 512)
glut.glutReshapeFunc(lambda w, h: self.reshape(w, h))
glut.glutDisplayFunc(lambda: self.display())
glut.glutKeyboardFunc(lambda k, x, y: self.keyboard(k, x, y))
# Primary offscreen framebuffer
self.mainfbo = fbo.FBO(self.columns,
32,
mag_filter=gl.GL_NEAREST,
min_filter=gl.GL_NEAREST)
# Initialize display shader
layoutfile = 'layout.json'
if self.displaytype == 'ws2811':
self.signalgenerator = displays.ws2811.signalgenerator(
layoutfile, supersample=self.supersample)
self.signalgenerator.setTexture(self.mainfbo.getTexture())
elif self.displaytype == 'hub75e':
self.signalgenerator = displays.hub75e.signalgenerator(
columns=self.columns,
rows=self.rows,
supersample=self.supersample,
order=self.order,
oe=self.oe,
extract=self.extract)
self.signalgenerator.setTexture(self.mainfbo.getTexture())
# Emulation shader
if self.emulate or self.preview:
self.texquad = geometry.simple.texquad()
self.texquad.setTexture(self.mainfbo.getTexture())
# Tree emulator
if self.emulate:
self.tree = assembly.tree.tree(layoutfile)
self.tree.setTexture(self.mainfbo.getTexture())
# Render
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
if not self.raw and not self.preview and not self.emulate:
glut.glutFullScreen()
def __init__(self, *args, **kwargs):
BaseCanvasBackend.__init__(self, *args)
title, size, position, show, vsync, resize, dec, fs, parent, context, \
= self._process_backend_kwargs(kwargs)
self._initialized = False
# Deal with context
if not context.istaken:
context.take('glut', self)
_set_config(context.config)
else:
raise RuntimeError('Glut cannot share contexts.')
glut.glutInitWindowSize(size[0], size[1])
self._id = glut.glutCreateWindow(title.encode('ASCII'))
if not self._id:
raise RuntimeError('could not create window')
glut.glutSetWindow(self._id)
_VP_GLUT_ALL_WINDOWS.append(self)
if fs is not False:
self._fullscreen = True
self._old_size = size
if fs is not True:
logger.warning('Cannot specify monitor for glut fullscreen, '
'using default')
glut.glutFullScreen()
else:
self._fullscreen = False
# Cache of modifiers so we can send modifiers along with mouse motion
self._modifiers_cache = ()
self._closed = False # Keep track whether the widget is closed
# Register callbacks
glut.glutDisplayFunc(self.on_draw)
glut.glutReshapeFunc(self.on_resize)
# glut.glutVisibilityFunc(self.on_show)
glut.glutKeyboardFunc(self.on_key_press)
glut.glutSpecialFunc(self.on_key_press)
glut.glutKeyboardUpFunc(self.on_key_release)
glut.glutMouseFunc(self.on_mouse_action)
glut.glutMotionFunc(self.on_mouse_motion)
glut.glutPassiveMotionFunc(self.on_mouse_motion)
_set_close_fun(self._id, self.on_close)
if position is not None:
self._vispy_set_position(*position)
if not show:
glut.glutHideWindow()
# Init
self._initialized = True
self._vispy_set_current()
self._vispy_canvas.events.initialize()
def keyboard_cb(key, x, y):
global controller, draw_axes, draw_grid, draw_stars, auto_rotate, pause
if key == b'q':
controller.quit()
exit()
elif key == b'f':
glut.glutFullScreen()
elif key == b'r':
auto_rotate = not auto_rotate
elif key == b'd':
draw_axes = not draw_axes
elif key == b'g':
draw_grid = not draw_grid
elif key == b's':
draw_stars = not draw_stars
elif key == b'p':
pause = not pause
pass
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)
self._initialize()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.kbd_handler = None
self.win_width = width
self.win_height = height
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow("Karaoke")
if not fullscreen:
glut.glutReshapeWindow(width, height)
else:
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
self.win_width = width
self.win_height = height
self.set_aspect(aspect)
self._on_reshape(width, height)
if fullscreen:
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)
def __init__(self, **kwargs):
BaseCanvasBackend.__init__(self, capability, SharedContext)
title, size, position, show, vsync, resize, dec, fs, context = \
self._process_backend_kwargs(kwargs)
_set_config(context)
glut.glutInitWindowSize(size[0], size[1])
self._id = glut.glutCreateWindow(title.encode('ASCII'))
if not self._id:
raise RuntimeError('could not create window')
glut.glutSetWindow(self._id)
_VP_GLUT_ALL_WINDOWS.append(self)
if fs is not False:
if isinstance(fs, int):
logger.warn('Cannot specify monitor for glut fullscreen, '
'using default')
glut.glutFullScreen()
# Cache of modifiers so we can send modifiers along with mouse motion
self._modifiers_cache = ()
self._closed = False # Keep track whether the widget is closed
# Register callbacks
glut.glutDisplayFunc(self.on_draw)
glut.glutReshapeFunc(self.on_resize)
# glut.glutVisibilityFunc(self.on_show)
glut.glutKeyboardFunc(self.on_key_press)
glut.glutSpecialFunc(self.on_key_press)
glut.glutKeyboardUpFunc(self.on_key_release)
glut.glutMouseFunc(self.on_mouse_action)
glut.glutMotionFunc(self.on_mouse_motion)
glut.glutPassiveMotionFunc(self.on_mouse_motion)
_set_close_fun(self._id, self.on_close)
self._vispy_canvas_ = None
if position is not None:
self._vispy_set_position(*position)
if not show:
glut.glutHideWindow()
def __init__(self, width=640, height=480, fullscreen=False, aspect=None):
self.kbd_handler = None
self.win_width = width
self.win_height = height
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB
| glut.GLUT_DEPTH)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow("BlitzLoop Karaoke")
if not fullscreen:
glut.glutReshapeWindow(width, height)
else:
glut.glutSetCursor(glut.GLUT_CURSOR_NONE)
self.win_width = width
self.win_height = height
self.set_aspect(aspect)
self._on_reshape(width, height)
if fullscreen:
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)
signalgenerator.setTexture(mainfbo.getTexture())
# Emulation shader
texquad = geometry.simple.texquad()
texquad.setTexture(mainfbo.getTexture())
# Tree emulator
tree = assembly.tree.tree(layoutfile)
tree.setTexture(mainfbo.getTexture())
# Projection matrix
M = np.eye(4, dtype=np.float32)
transforms.scale(M, 1, 1, 1)
# Effect
try:
i = __import__('assembly.%s' % args.effect)
effect = getattr(getattr(i, args.effect), args.effect)()
effect.setProjection(M)
except ImportError:
print('Unable to initialize effect %s' % args.effect)
raise
if args.music:
start_music()
if not args.raw and not args.preview and not args.emulate:
glut.glutFullScreen()
glut.glutMainLoop()
# format histogram output
titleStr = "Bin: "
valueStr = "n: "
for b in bins[1:len(bins)]:
titleStr += "{:>8}".format(b)
for n in binVals:
valueStr += "{:>8}".format(n)
# print stuff
print("Frequency list:")
print(freq_list)
print()
print("Histogram values:")
print(titleStr)
print(valueStr)
if __name__ == '__main__':
initialize_presentation() # get global objects needed for all of this to work
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE) # initialize display mode as double buffering
glut.glutCreateWindow('') # create window
glut.glutDisplayFunc(render_routine) # set display callback handler for window re-paint
glut.glutKeyboardFunc(key_pressed) # set callback handler for keyboard events
glut.glutTimerFunc(0, update_left_checkerboard, 0)
glut.glutTimerFunc(0, update_right_checkerboard, 0)
glut.glutFullScreen() # put window in full screen
glut.glutMainLoop() # enter main events processing loop
def keyboard(self, key, x, y):
global ALPHA
global COLORMAP
global CONTRAST
global FULLSCREEN
global POINT_SIZE
global RECORDSCREEN
global TRACEORBITS
global ZOOM_FACTOR
(ps_min, ps_max) = gl.glGetFloatv(gl.GL_ALIASED_POINT_SIZE_RANGE)
if key == ' ':
self.rotate['x'] = 0
self.rotate['y'] = 0
self.rotate['z'] = 0
elif key == '+':
POINT_SIZE += 1
if POINT_SIZE > ps_max:
POINT_SIZE = ps_max
elif key == '-':
POINT_SIZE -= 1
if POINT_SIZE < ps_min:
POINT_SIZE = ps_min
elif key == '<':
self.rotate['z'] -= 1
elif key == '>':
self.rotate['z'] += 1
elif key in '0123456789':
COLORMAP = int(key)
elif key == 'a':
ALPHA /= 1.03125
if ALPHA < 0.0:
ALPHA = 0.0
elif key == 'A':
ALPHA *= 1.03125
if ALPHA > 1.0:
ALPHA = 1.0
elif key == 'c':
CONTRAST *= 1.015625
if CONTRAST > 256.0:
CONTRAST = 256.0
elif key == 'C':
CONTRAST /= 1.015625
if CONTRAST < 0.0625:
CONTRAST = 0.0625
elif key == 'r':
if not COLORMASK['r']:
COLORMASK['r'] = True
COLORMASK['g'] = False
COLORMASK['b'] = False
else:
COLORMASK['r'] = False
elif key == 'g':
if not COLORMASK['g']:
COLORMASK['r'] = False
COLORMASK['g'] = True
COLORMASK['b'] = False
else:
COLORMASK['g'] = False
elif key == 'b':
if not COLORMASK['b']:
COLORMASK['r'] = False
COLORMASK['g'] = False
COLORMASK['b'] = True
else:
COLORMASK['b'] = False
elif key == 'Z':
ZOOM_FACTOR *= 1.03125
elif key == 'z':
ZOOM_FACTOR /= 1.03125
elif key == 'o' or key == 'O':
if not TRACEORBITS:
TRACEORBITS = True
else:
TRACEORBITS = False
elif key == 'f' or key == 'F':
if not FULLSCREEN:
glut.glutFullScreen()
FULLSCREEN = True
else:
glut.glutReshapeWindow(WINDOW_WIDTH, WINDOW_HEIGHT)
FULLSCREEN = False
elif key == 's' or key == 'S':
if not RECORDSCREEN:
RECORDSCREEN = True
else:
RECORDSCREEN = False
elif key == ESCAPE:
self.exitgl = True
glut.glutLeaveMainLoop()
glut.glutHideWindow()
glut.glutSetWindow(self.window_handle)
glut.glutPostRedisplay()
if __name__ == '__main__':
glut.glutInit(sys.argv)
width, height = 640, 480
glut.glutInitDisplayMode(glut.GLUT_RGBA
| glut.GLUT_DOUBLE
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(width, height)
glut.glutInitWindowPosition(0, 0)
# assign to global window variable
window = glut.glutCreateWindow('Invaders')
if config.fullscreen_mode:
glut.glutFullScreen()
world = World(config.mode[0])
# draw scene on display and between other calculations
draw_func = display.get_display(world)
glut.glutDisplayFunc(draw_func)
glut.glutIdleFunc(draw_func)
glut.glutReshapeFunc(resize_func)
glut.glutKeyboardFunc(keyboard.normal_keys)
glut.glutSpecialFunc(keyboard.get_special_keys(world))
init_environment(width, height)
glut.glutMainLoop()
def keyboard(self, key, x, y):
global ALPHA
global COLORMAP
global CONTRAST
global FULLSCREEN
global POINT_SIZE
global RECORDSCREEN
global TRACEORBITS
global ZOOM_FACTOR
(ps_min, ps_max) = gl.glGetFloatv(gl.GL_ALIASED_POINT_SIZE_RANGE)
if key == " ":
self.rotate["x"] = 0
self.rotate["y"] = 0
self.rotate["z"] = 0
elif key == "+":
POINT_SIZE += 1
if POINT_SIZE > ps_max:
POINT_SIZE = ps_max
elif key == "-":
POINT_SIZE -= 1
if POINT_SIZE < ps_min:
POINT_SIZE = ps_min
elif key == "<":
self.rotate["z"] -= 1
elif key == ">":
self.rotate["z"] += 1
elif key in "0123456789":
COLORMAP = int(key)
elif key == "a":
ALPHA /= 1.03125
if ALPHA < 0.0:
ALPHA = 0.0
elif key == "A":
ALPHA *= 1.03125
if ALPHA > 1.0:
ALPHA = 1.0
elif key == "c":
CONTRAST *= 1.015625
if CONTRAST > 256.0:
CONTRAST = 256.0
elif key == "C":
CONTRAST /= 1.015625
if CONTRAST < 0.0625:
CONTRAST = 0.0625
elif key == "r":
if not COLORMASK["r"]:
COLORMASK["r"] = True
COLORMASK["g"] = False
COLORMASK["b"] = False
else:
COLORMASK["r"] = False
elif key == "g":
if not COLORMASK["g"]:
COLORMASK["r"] = False
COLORMASK["g"] = True
COLORMASK["b"] = False
else:
COLORMASK["g"] = False
elif key == "b":
if not COLORMASK["b"]:
COLORMASK["r"] = False
COLORMASK["g"] = False
COLORMASK["b"] = True
else:
COLORMASK["b"] = False
elif key == "Z":
ZOOM_FACTOR *= 1.03125
elif key == "z":
ZOOM_FACTOR /= 1.03125
elif key == "o" or key == "O":
if not TRACEORBITS:
TRACEORBITS = True
else:
TRACEORBITS = False
elif key == "f" or key == "F":
if not FULLSCREEN:
glut.glutFullScreen()
FULLSCREEN = True
else:
glut.glutReshapeWindow(WINDOW_WIDTH, WINDOW_HEIGHT)
FULLSCREEN = False
elif key == "s" or key == "S":
if not RECORDSCREEN:
RECORDSCREEN = True
else:
RECORDSCREEN = False
elif key == ESCAPE:
self.exitgl = True
glut.glutLeaveMainLoop()
glut.glutHideWindow()
glut.glutSetWindow(self.window_handle)
glut.glutPostRedisplay()
