def main():
global window
# For now we just pass glutInit one empty argument. I wasn't sure what should or could be passed in (tuple, list, ...)
# Once I find out the right stuff based on reading the PyOpenGL source, I'll address this.
lutAsString = buildBitsLUT()
GLUT.glutInit([])
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH)
# get a 640 x 480 window
GLUT.glutInitWindowSize(800, 600)
# the window starts at the upper left corner of the screen
GLUT.glutInitWindowPosition(0, 0)
window = GLUT.glutCreateWindow("Jeff Molofee's GL Code Tutorial ... NeHe '99")
# glutFullScreen()
#register callbacks
GLUT.glutIdleFunc(DrawGLScene)
GLUT.glutReshapeFunc(ReSizeGLScene)
GLUT.glutKeyboardFunc(keyPressed)
GLUT.glutDisplayFunc(DrawGLScene)
InitGL(800, 600)
GLUT.glutMainLoop()
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 run_sim_with_window(self):
print("\n")
print("space bar: simulation on/off")
print("' ': run/stop simulation")
print("'a': run/stop animation")
print("'[' and ']': play one frame backward and forward")
# Init glut
GLUT.glutInit(())
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_MULTISAMPLE | GLUT.GLUT_ALPHA
| GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(*self.window_size)
GLUT.glutInitWindowPosition(0, 0)
self.window = GLUT.glutCreateWindow(self.title)
# Init functions
# glutFullScreen()
GLUT.glutDisplayFunc(self.drawGL)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.resizeGL)
GLUT.glutKeyboardFunc(self.keyPressed)
GLUT.glutMouseFunc(self.mouseFunc)
GLUT.glutMotionFunc(self.motionFunc)
GLUT.glutTimerFunc(25, self.renderTimer, 1)
self.initGL(*self.window_size)
# Run
GLUT.glutMainLoop()
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):
"""
Basic GLUT init and glut function definition.
Notes
-----
`self.render_obj` is initialized here, which is then being used and drawn in `self.display`
"""
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_DEPTH | glut.GLUT_MULTISAMPLE)
glut.glutCreateWindow('Frightened Glut Rabbit')
glut.glutReshapeWindow(Global.WIDTH, Global.HEIGHT)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.glutMousePressEvent)
glut.glutMotionFunc(self.glutMouseMoveEvent)
glut.glutTimerFunc(Global.REFRESH_TIMER, self.onTimer,
Global.REFRESH_TIMER)
self.buildProgram()
self.reshape(Global.WIDTH, Global.HEIGHT)
# set object to be rendered
self.render_obj = default_obj()
# For checking if need to swap
self.standalone = True
def __init__(self,
world,
title='',
height=500,
width=500):
self.world = world
self.time_interval = 10
GLUT.glutInit(sys.argv)
self.lastTime = GLUT.glutGet(GLUT.GLUT_ELAPSED_TIME)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE |
GLUT.GLUT_RGB |
GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(height, width)
GLUT.glutCreateWindow(title)
GLUT.glutDisplayFunc(self.render)
GLUT.glutReshapeFunc(self.onSize)
self.init = False
#initialized to actual values in setupView
self.viewport_left = 0
self.viewport_bottom = 0
self.viewport_height = 0
self.viewport_width = 0
self.timeStep = 1
self.timeElapsed = self.time_interval / 1000.0
def run(self, ):
print("\n")
print("space bar: simulation on/off")
print("' ': run/stop simulation")
print("'a': run/stop animation")
print("'[' and ']': play one frame backward and forward")
# Init glut
GLUT.glutInit(())
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA |
GLUT.GLUT_DOUBLE |
GLUT.GLUT_MULTISAMPLE |
GLUT.GLUT_ALPHA |
GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(*self.window_size)
GLUT.glutInitWindowPosition(0, 0)
self.window = GLUT.glutCreateWindow(self.title)
# Init functions
# glutFullScreen()
GLUT.glutDisplayFunc(self.drawGL)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.resizeGL)
GLUT.glutKeyboardFunc(self.keyPressed)
GLUT.glutMouseFunc(self.mouseFunc)
GLUT.glutMotionFunc(self.motionFunc)
GLUT.glutTimerFunc(25, self.renderTimer, 1)
self.initGL(*self.window_size)
# Run
GLUT.glutMainLoop()
def main(self):
self.location = np.array([0.0,0.0,1500.0])
self.focus = np.array([0.0,0.0,0.0])
self.up = np.array([1.0,0.0,0.0])
self.mousex = 0
self.mousey = 0
self.mouse_drag = gl.GL_FALSE
# Wire up GL
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGB | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
glut.glutInitWindowSize(500,500)
glut.glutInitWindowPosition(10,10)
glut.glutCreateWindow("Laspy+OpenGL Pointcloud")
glut.glutDisplayFunc(self.display)
glut.glutReshapeFunc(self.reshape)
glut.glutMouseFunc(self.mouse)
glut.glutMotionFunc(self.mouse_motion)
glut.glutKeyboardFunc(self.keyboard)
gl.glClearColor(0.0,0.0,0.0,1.0)
glut.glutTimerFunc(10,self.timerEvent,1)
glut.glutMainLoop()
return 0
def __init__(self, wWidth, wHeight, filename):
global g_rs, g_nx, g_ny, g_msecs
g_rs = PVReadSparse(filename)
g_nx = g_rs.nx
g_ny = g_rs.ny
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(wWidth, wHeight)
glut.glutInitWindowPosition(0, 0)
window = glut.glutCreateWindow("PetaVision Activity")
gl.glTranslatef(-1.0, 1.0, -2.5)
# register callbacks
glut.glutReshapeFunc(reSizeGLScene)
glut.glutTimerFunc(g_msecs, getNextRecord, 1)
glut.glutDisplayFunc(drawGLScene)
glut.glutKeyboardFunc(keyPressed)
print "nx==", g_nx
print "ny==", g_ny
self.initGL(wWidth, wHeight)
def run(self):
glut.glutInit(sys.argv)
glut.glutInitWindowSize(500, 500)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
self.win = glut.glutCreateWindow(b'Molecular visualizer')
glut.glutDisplayFunc(self.display)
glut.glutReshapeFunc(self.reshape)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMotionFunc(self.rotate)
glut.glutMouseFunc(self.mouse)
gl.glClearColor(0, 0, 0, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_LIGHT0)
gl.glColorMaterial(gl.GL_FRONT, gl.GL_DIFFUSE)
gl.glEnable(gl.GL_COLOR_MATERIAL)
# very diffuse and dark specular highlights, to make black visible
gl.glMaterial(gl.GL_FRONT, gl.GL_SPECULAR, (.1, .1, .1, 1))
gl.glMaterial(gl.GL_FRONT, gl.GL_SHININESS, 5)
self.displist = gl.glGenLists(1)
gl.glNewList(self.displist, gl.GL_COMPILE)
self.draw_atoms(self.molecule)
gl.glEndList()
glut.glutMainLoop()
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 run(self):
GLUT.glutInit()
GLUT.glutSetOption(GLUT.GLUT_MULTISAMPLE, 4)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH
| GLUT.GLUT_MULTISAMPLE)
self.width = 1200
self.height = 720
GLUT.glutInitWindowSize(self.width, self.height)
GLUT.glutInitWindowPosition(100, 100)
self.window = GLUT.glutCreateWindow(self.title)
self.init_program()
self.clear()
self.show_loading_screen()
self.init_line_buffer()
self.load_line_buffer()
GLUT.glutDisplayFunc(self.display)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.reshape)
GLUT.glutKeyboardFunc(self.keyboard)
GLUT.glutSpecialFunc(self.special)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.motion)
GLUT.glutPassiveMotionFunc(self.motion)
GLUT.glutMainLoop()
def main():
window_width = 600
window_height = 600
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(
cast(int, glut.GLUT_RGB) | cast(int, glut.GLUT_SINGLE)
| cast(int, glut.GLUT_DEPTH))
glut.glutInitWindowSize(window_width, window_height) # window size
glut.glutInitWindowPosition(100, 100) # window position
glut.glutCreateWindow("mmdpy") # show window
glut.glutDisplayFunc(display) # draw callback function
# glut.glutIdleFunc(display)
glut.glutReshapeFunc(reshape) # resize callback function
parser = argparse.ArgumentParser(description="MMD model viewer sample.")
parser.add_argument("-p", type=str, help="MMD model file name.")
parser.add_argument("-v", type=str, help="MMD motion file name.")
parser.add_argument("--bone",
type=bool,
default=False,
help="Print bone informations.")
args = parser.parse_args()
model_name = args.p
motion_name = args.v
global bone_information
bone_information = args.bone
print(model_name)
print(motion_name)
init(window_width, window_height, model_name, motion_name)
glut.glutTimerFunc(1000 // FPS, event, 0)
glut.glutMainLoop()
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):
if not self.__is_initialized:
self.__is_initialized = True
sys.argv = glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH)
self.__windowsize = (400,400)
glut.glutInitWindowSize(self.__windowsize[0],self.__windowsize[1])
glut.glutCreateWindow(self.__name)
gl.glShadeModel(gl.GL_SMOOTH)
gl.glEnable(gl.GL_CULL_FACE)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
glut.glutDisplayFunc(self.__display)
glut.glutMouseFunc(self.__onMouse)
glut.glutMotionFunc(self.__onMouseMotion)
glut.glutMouseWheelFunc(self.__onWheel)
glut.glutReshapeFunc(self.__onReshape)
self.__onReshape(400,400)
def sleep_forever():
self.__am_slow = False
if not self._window_closed:
print('program complete, but still running visualization...')
while True:
glut.glutMainLoopEvent()
atexit.register(sleep_forever)
def run(self):
glut.glutInit(sys.argv)
glut.glutInitWindowSize(500, 500)
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_DEPTH)
self.win = glut.glutCreateWindow(b'Molecular visualizer')
glut.glutDisplayFunc(self.display)
glut.glutReshapeFunc(self.reshape)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMotionFunc(self.rotate)
glut.glutMouseFunc(self.mouse)
gl.glClearColor(0, 0, 0, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_LIGHTING)
gl.glEnable(gl.GL_LIGHT0)
gl.glColorMaterial(gl.GL_FRONT, gl.GL_DIFFUSE)
gl.glEnable(gl.GL_COLOR_MATERIAL)
# very diffuse and dark specular highlights, to make black visible
gl.glMaterial(gl.GL_FRONT, gl.GL_SPECULAR, (.1, .1, .1, 1))
gl.glMaterial(gl.GL_FRONT, gl.GL_SHININESS, 5)
self.displist = gl.glGenLists(1)
gl.glNewList(self.displist, gl.GL_COMPILE)
self.draw_atoms(self.molecule)
gl.glEndList()
glut.glutMainLoop()
def main():
global window
# For now we just pass glutInit one empty argument. I wasn't sure what should or could be passed in (tuple, list, ...)
# Once I find out the right stuff based on reading the PyOpenGL source, I'll address this.
lutAsString = buildBitsLUT()
GLUT.glutInit([])
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE
| GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH)
# get a 640 x 480 window
GLUT.glutInitWindowSize(800, 600)
# the window starts at the upper left corner of the screen
GLUT.glutInitWindowPosition(0, 0)
window = GLUT.glutCreateWindow(
"Jeff Molofee's GL Code Tutorial ... NeHe '99")
# glutFullScreen()
#register callbacks
GLUT.glutIdleFunc(DrawGLScene)
GLUT.glutReshapeFunc(ReSizeGLScene)
GLUT.glutKeyboardFunc(keyPressed)
GLUT.glutDisplayFunc(DrawGLScene)
InitGL(800, 600)
GLUT.glutMainLoop()
def gl_init(self):
# sys.stderr.write("Starting GLUTContext.gl_init\n")
if self is not GLUTContext._default_instance:
# sys.stderr.write("Making a GLUT window.\n")
GLUT.glutInitWindowSize(self._width, self._height)
GLUT.glutInitWindowPosition(0, 0)
self.window = GLUT.glutCreateWindow(
bytes(self._title, encoding="UTF-8"))
GLUT.glutSetWindow(self.window)
GLUT.glutMouseFunc(lambda button, state, x, y: self.
mouse_button_handler(button, state, x, y))
GLUT.glutReshapeFunc(
lambda width, height: self.resize2d(width, height))
GLUT.glutDisplayFunc(lambda: self.draw())
GLUT.glutVisibilityFunc(
lambda state: self.window_visibility_handler(state))
# Right now, the timer just prints FPS
GLUT.glutTimerFunc(0, lambda val: self.timer(val), 0)
GLUT.glutCloseFunc(lambda: self.cleanup())
for coltype in object_collection.GLObjectCollection.collection_classes:
self.object_collections.append(
object_collection.GLObjectCollection.
collection_classes[coltype](self))
# self.object_collections.append(object_collection.SimpleObjectCollection(self))
# self.object_collections.append(object_collection.CurveCollection(self))
self.window_is_initialized = True
GLUTContext._instances.append(self)
def main():
light_position = (7, 2, 1)
GLUT.glutInit(argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
larguraTela = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
alturaTela = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
larguraJanela = round(2 * larguraTela / 3)
alturaJanela = round(2 * alturaTela / 3)
GLUT.glutInitWindowSize(larguraJanela, alturaJanela)
GLUT.glutInitWindowPosition(round((larguraTela - larguraJanela) / 2), round((alturaTela - alturaJanela) / 2))
GLUT.glutCreateWindow(janela)
GLUT.glutReshapeFunc(reshape)
GLUT.glutDisplayFunc(draw)
GLUT.glutMouseFunc(clique)
GL.glShadeModel(GL.GL_SMOOTH)
GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, dados[0][0])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, dados[0][1])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, dados[0][2])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, dados[0][3])
GL.glEnable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_LIGHT0)
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position)
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClearColor(*corFundo)
GLU.gluPerspective(45, larguraJanela / alturaJanela, 0.1, 50.0)
GLUT.glutTimerFunc(50, timer, 1)
GLUT.glutMainLoop()
def __init__(self, *args, **kwargs):
BaseCanvasBackend.__init__(self)
title, size, show, position = self._process_backend_kwargs(kwargs)
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)
# 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 main():
global wmngr_glut
###################
# GLUT Window Initialization
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB
| glut.GLUT_DEPTH) # zBuffer
glut.glutInitWindowSize(600, 600)
glut.glutInitWindowPosition(100, 100)
glut.glutCreateWindow("Simple GLUT")
# Register callbacks
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutMouseFunc(mouse)
glut.glutMotionFunc(motion)
glut.glutKeyboardFunc(keyboard)
glut.glutSpecialFunc(special)
glut.glutIdleFunc(idle)
wmngr_glut = dfm2.gl.glut.WindowManagerGLUT(0.3)
dfm2.gl.setSomeLighting()
####
# Turn the flow of control over to GLUT
glut.glutMainLoop()
def main():
GLUT.glutInit(sys.argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(320, 240)
global window
window = GLUT.glutCreateWindow("Babal")
GLUT.glutDisplayFunc(display_cb)
GLUT.glutVisibilityFunc(visibility_cb)
GLUT.glutReshapeFunc(reshape_cb)
GLUT.glutIgnoreKeyRepeat(1)
GLUT.glutKeyboardFunc(keyboard_cb)
GLUT.glutKeyboardUpFunc(keyboard_up_cb)
GLUT.glutSpecialFunc(special_cb)
GLUT.glutSpecialUpFunc(special_up_cb)
GLUT.glutJoystickFunc(joystick_cb, 0)
map_file = None
if len(sys.argv) > 1:
map_file = open(sys.argv[1])
global game
game = Game(map_file)
gl_draw.init(GL, GLU, game)
# reshape_cb gets called when window is made visible
GLUT.glutMainLoop()
def __init__(self,
width: int,
height: int,
title: str,
camera: bool = False):
self.__Daytime = True
self.__enableCamera = camera
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutInitWindowSize(width, height)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow(title)
glut.glutReshapeFunc(self.__window_resize)
glut.glutDisplayFunc(self.__display)
glut.glutKeyboardFunc(self.__keyboardDown)
glut.glutKeyboardUpFunc(self.__keyboardUp)
glut.glutMotionFunc(self.__mouse_look_clb)
self._create_shader()
self.setSky(True)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
self.__ElementsList = []
self.__camera = Camera()
self.__lastX = width / 2
self.__lastY = height / 2
self.__first_mouse = True
self.__left = False
self.__right = False
self.__forward = False
self.__backward = False
def Visualization(title, drawScene=DrawGLScene, width=320, height=200,
handleKey=None):
global window, _DrawCurrentSceneFunc, _KeyHandlerFunc
GLUT.glutInit(sys.argv)
_DrawCurrentSceneFunc = drawScene
if handleKey:
_KeyHandlerFunc = handleKey
# Select type of Display mode:
# Double buffer
# RGBA color
# Alpha components supported
# Depth buffer
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE \
| GLUT.GLUT_DEPTH)
# get a 640 x 480 window
GLUT.glutInitWindowSize(640, 480)
# the window starts at the upper left corner of the screen
GLUT.glutInitWindowPosition(0, 0)
# Okay, like the C version we retain the window id to use when closing, but
# for those of you new to Python (like myself), remember this assignment
# would make the variable local and not global if it weren't for the global
# declaration at the start of main.
window = GLUT.glutCreateWindow(title)
# Register the drawing function with glut, BUT in Python land, at least
# using PyOpenGL, we need to set the function pointer and invoke a function
# to actually register the callback, otherwise it would be very much like
# the C version of the code.
GLUT.glutDisplayFunc(DrawGLScene)
# Uncomment this line to get full screen.
# GLUT.glutFullScreen()
# When we are doing nothing, redraw the scene.
GLUT.glutIdleFunc(DrawGLScene)
# Register the function called when our window is resized.
GLUT.glutReshapeFunc(ReSizeGLScene)
# Register the function called when the keyboard is pressed.
GLUT.glutKeyboardFunc(keyPressed)
# Register the function called when the mouse is pressed.
GLUT.glutMouseFunc(mousePressed)
# Register the function called when the mouse is pressed.
GLUT.glutMotionFunc(mouseMoved)
# Initialize our window.
InitGL(640, 480)
# Start Event Processing Engine
GLUT.glutMainLoop()
def __init__(self, geos, vertex_code, fragment_code):
self.time = time.time()
num_vertices = np.sum([len(g) for g in geos])
data = np.zeros(num_vertices, [("position", np.float32, 2),
("color", np.float32, 4)])
cs = []
vs = []
for g in geos:
for c in g.colors:
cs.append(c)
for v in g.vertices:
vs.append(v)
data["color"] = cs
data["position"] = vs
data["position"] = 0.5 * data["position"]
self.data = data
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow("Hello world!")
glut.glutReshapeWindow(512, 512)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutIdleFunc(self.idle)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.mouse)
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
gl.glUseProgram(program)
self.buffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data,
gl.GL_DYNAMIC_DRAW)
stride = self.data.strides[0]
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["position"].itemsize)
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)
def interaction(disp=display,resh=reshape, key=keyboard):
global mi
mi=mouse.MouseInteractor(.01,0.02)
mi.registerCallbacks( )
glut.glutDisplayFunc(disp)
glut.glutReshapeFunc(resh)
glut.glutKeyboardFunc(key)
def init_glut():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow('')
glut.glutReshapeWindow(RESOLUTION[0], RESOLUTION[1])
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
glut.glutTimerFunc(0, timer, 0)
def main():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow('Hello world!')
glut.glutReshapeWindow(512, 512)
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
glut.glutMainLoop()
def interaction(disp=display, resh=reshape, key=keyboard):
global mi
mi = mouse.MouseInteractor(.01, 0.02)
mi.registerCallbacks()
glut.glutDisplayFunc(disp)
glut.glutReshapeFunc(resh)
glut.glutKeyboardFunc(key)
def init_glut(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow('')
glut.glutReshapeWindow(self.resolution[0], self.resolution[1])
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyboard)
glut.glutTimerFunc(0, self.timer, 0)
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, width=256, height=256, title=None, visible=True, aspect=None,
decoration=True, fullscreen=False, config=None, context=None, color=(0,0,0,1), vsync=False):
if vsync:
log.warn('vsync not implemented for osxglut backend')
if len(__windows__) > 0:
log.critical(
"""OSXGLUT backend is unstable with more than one window.\n"""
"""Exiting...""")
sys.exit(0)
window.Window.__init__(self, width=width,
height=height,
title=title,
visible=visible,
aspect=aspect,
decoration=decoration,
fullscreen=fullscreen,
config=config,
context=context,
color=color)
if config is None:
config = configuration.Configuration()
set_configuration(config)
self._native_window = glut.glutCreateWindow( self._title )
if bool(glut.glutSetOption):
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
glut.GLUT_ACTION_CONTINUE_EXECUTION)
glut.glutSetOption(glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS,
glut.GLUT_ACTION_CONTINUE_EXECUTION)
glut.glutWMCloseFunc( self._close )
glut.glutDisplayFunc( self._display )
glut.glutReshapeFunc( self._reshape )
glut.glutKeyboardFunc( self._keyboard )
glut.glutKeyboardUpFunc( self._keyboard_up )
glut.glutMouseFunc( self._mouse )
glut.glutMotionFunc( self._motion )
glut.glutPassiveMotionFunc( self._passive_motion )
glut.glutVisibilityFunc( self._visibility )
glut.glutEntryFunc( self._entry )
glut.glutSpecialFunc( self._special )
glut.glutSpecialUpFunc( self._special_up )
glut.glutReshapeWindow( self._width, self._height )
if visible:
glut.glutShowWindow()
else:
glut.glutHideWindow()
# This ensures glutCheckLoop never blocks
def on_idle(): pass
glut.glutIdleFunc(on_idle)
__windows__.append(self)
def __init__(self, geos, vertex_code, fragment_code):
self.time = time.time()
num_vertices = np.sum([len(g) for g in geos])
data = np.zeros(num_vertices, [("position", np.float32, 2),
("color", np.float32, 4)])
cs = []
vs = []
for g in geos:
for c in g.colors:
cs.append(c)
for v in g.vertices:
vs.append(v)
data["color"] = cs
data["position"] = vs
data["position"] = 0.5 * data["position"]
self.data = data
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow("Hello world!")
glut.glutReshapeWindow(512,512)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutIdleFunc(self.idle)
glut.glutKeyboardFunc(self.keyboard)
glut.glutMouseFunc(self.mouse)
program = gl.glCreateProgram()
vertex = gl.glCreateShader(gl.GL_VERTEX_SHADER)
fragment = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(vertex, vertex_code)
gl.glShaderSource(fragment, fragment_code)
gl.glCompileShader(vertex)
gl.glCompileShader(fragment)
gl.glAttachShader(program, vertex)
gl.glAttachShader(program, fragment)
gl.glLinkProgram(program)
gl.glDetachShader(program, vertex)
gl.glDetachShader(program, fragment)
gl.glUseProgram(program)
self.buffer = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glBufferData(gl.GL_ARRAY_BUFFER, self.data.nbytes, self.data, gl.GL_DYNAMIC_DRAW)
stride = self.data.strides[0]
offset = ctypes.c_void_p(0)
loc = gl.glGetAttribLocation(program, "position")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, stride, offset)
offset = ctypes.c_void_p(self.data.dtype["position"].itemsize)
loc = gl.glGetAttribLocation(program, "color")
gl.glEnableVertexAttribArray(loc)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.buffer)
gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, stride, offset)
loc = gl.glGetUniformLocation(program, "scale")
gl.glUniform1f(loc, 1.0)
def initAndRunDevice(templateGlutSystem):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow(b'raVEngine_py')
glut.glutReshapeWindow(512, 512)
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(templateGlutSystem.display)
glut.glutKeyboardFunc(keyboard)
glut.glutMotionFunc(mouse)
glut.glutIdleFunc(templateGlutSystem.combineUpdateAndDisplay)
glut.glutMainLoop()
def on(self):
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB)
glut.glutInitWindowSize(self.ww, self.hh)
glut.glutInitWindowPosition(300, 100)
glut.glutInit(sys.argv)
glut.glutCreateWindow(b"PCViewer")
glut.glutDisplayFunc(self.__draw__)
gl.glEnable(gl.GL_DEPTH_TEST)
glut.glutReshapeFunc(self.__reshape__)
glut.glutSpecialFunc(self.__specialkeys__)
glut.glutMainLoop()
def __init__(self,
width=256,
height=256,
title=None,
visible=True,
decoration=True,
fullscreen=False,
config=None,
context=None):
if len(__windows__) > 0:
log.critical(
"""OSXGLUT backend is unstable with more than one window.\n"""
"""Exiting...""")
sys.exit(0)
window.Window.__init__(self, width, height, title, visible, decoration,
fullscreen, config, context)
if config is None:
config = configuration.Configuration()
set_configuration(config)
self._native_window = glut.glutCreateWindow(self._title)
if bool(glut.glutSetOption):
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE,
glut.GLUT_ACTION_CONTINUE_EXECUTION)
glut.glutSetOption(glut.GLUT_ACTION_GLUTMAINLOOP_RETURNS,
glut.GLUT_ACTION_CONTINUE_EXECUTION)
glut.glutWMCloseFunc(self._close)
glut.glutDisplayFunc(self._display)
glut.glutReshapeFunc(self._reshape)
glut.glutKeyboardFunc(self._keyboard)
glut.glutKeyboardUpFunc(self._keyboard_up)
glut.glutMouseFunc(self._mouse)
glut.glutMotionFunc(self._motion)
glut.glutPassiveMotionFunc(self._passive_motion)
glut.glutVisibilityFunc(self._visibility)
glut.glutEntryFunc(self._entry)
glut.glutSpecialFunc(self._special)
glut.glutSpecialUpFunc(self._special_up)
glut.glutReshapeWindow(self._width, self._height)
if visible:
glut.glutShowWindow()
else:
glut.glutHideWindow()
# This ensures glutCheckLoop never blocks
def on_idle():
pass
glut.glutIdleFunc(on_idle)
__windows__.append(self)
def main():
glut.glutInit()
glut.glutInitWindowSize(100, 100)
glut.glutCreateWindow('Mehdi')
init()
glut.glutDisplayFunc(display)
glut.glutReshapeFunc(resize(100, 100))
glut.glutMainLoop()
def _init_glut(self, time):
if type(time) != bytes:
raise TypeError
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutCreateWindow(time)
glut.glutReshapeWindow(700, 700)
glut.glutReshapeFunc(self.set_window_size)
glut.glutDisplayFunc(self._display)
glut.glutKeyboardFunc(self._keyboard)
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 main():
GLUT.glutInit(argv)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA
| GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE)
# Creating a screen with good resolution proportions
screen_width = GLUT.glutGet(GLUT.GLUT_SCREEN_WIDTH)
screen_height = GLUT.glutGet(GLUT.GLUT_SCREEN_HEIGHT)
window_width = round(2 * screen_width / 3)
window_height = round(2 * screen_height / 3)
GLUT.glutInitWindowSize(window_width, window_height)
GLUT.glutInitWindowPosition(round((screen_width - window_width) / 2),
round((screen_height - window_height) / 2))
GLUT.glutCreateWindow(window_name)
# Reshape Function
GLUT.glutReshapeFunc(reshape)
# Drawing Function
GLUT.glutDisplayFunc(draw)
# Input Functions
GLUT.glutSpecialFunc(special_key_pressed)
GLUT.glutKeyboardFunc(key_pressed)
GLUT.glutMouseFunc(mouse_click)
GLUT.glutMotionFunc(mouse_move)
#GL.glShadeModel(GL.GL_FLAT)
GL.glShadeModel(GL.GL_SMOOTH)
#First Material
GL.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, materials[0][0])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, materials[0][1])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, materials[0][2])
GL.glMaterialfv(GL.GL_FRONT, GL.GL_SHININESS, materials[0][3])
light_position = (10, 0, 0)
GL.glEnable(GL.GL_LIGHTING)
GL.glEnable(GL.GL_LIGHT0)
GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position)
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glClearColor(*background_color)
# Pre-render camera positioning
GLU.gluPerspective(45, window_width / window_height, 0.1, 50.0)
GLUT.glutTimerFunc(50, timer, 1)
GLUT.glutMainLoop()
def handler(self, h):
self._handler = h
# mapping
glt.glutMouseFunc(h.onMouseClicked)
glt.glutReshapeFunc(h.onReshape)
glt.glutKeyboardFunc(h.onKeyPress)
# create menu
glt.glutCreateMenu(h.onMenuClick)
for k, v in h.menuItems.items():
glt.glutAddMenuEntry(k, v)
glt.glutAttachMenu(glt.GLUT_RIGHT_BUTTON)
def _glut_init(self):
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_RGB | glut.GLUT_SINGLE)
glut.glutInitWindowSize(self.window_size, self.window_size)
glut.glutInitWindowPosition(0, 0)
glut.glutCreateWindow(sys.argv[0])
glut.glutDisplayFunc(self._display)
glut.glutSpecialFunc(self._on_key_press)
glut.glutMouseFunc(self._on_mouse_click)
glut.glutMotionFunc(self._on_mouse_move)
glut.glutReshapeFunc(self._on_window_resize)
glut.glutIdleFunc(self._on_idle)
glut.glutMainLoop()
def draw_loop(self,draw_func0):
# Register callbacks
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutMouseFunc(self.mouse)
glut.glutMotionFunc(self.motion)
glut.glutKeyboardFunc(self.keyboard)
glut.glutSpecialFunc(self.special)
glut.glutIdleFunc(self.idle)
self.draw_func = draw_func0
glut.glutMainLoop()
def __init__(self, limit_fps=100, show_fps=True, window_name='GlutWindow', size=np.asarray([768, 512])):
self.limit_fps = limit_fps
self.show_fps = show_fps
self.window_name = window_name
self.window_size = size
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA)
glut.glutInitWindowPosition(*GlutWindow.allocate_window_position(self.window_size))
self.window_handle = glut.glutCreateWindow(self.window_name)
glut.glutReshapeWindow(*self.window_size)
glut.glutReshapeFunc(self.reshape)
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.keyboard)
def initGlut():
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH)
glut.glutInitWindowSize(canvasWidth, canvasHeight)
glut.glutInitWindowPosition(100, 100)
glut.glutCreateWindow('Particles')
glut.glutDisplayFunc(displayCallback)
glut.glutIdleFunc(displayCallback)
glut.glutReshapeFunc(reshapeCallback)
glut.glutKeyboardFunc(keyboardCallback)
logging.info("Finished Setting Up Glut Loop")
glut.glutMainLoop()
def __init__(self, width=None, height=None, caption=None, visible=True, fullscreen=False):
event.EventDispatcher.__init__(self)
self._event_queue = []
if width and width > 0:
self._width = width
else:
self._width = Window._default_width
if height and height > 0:
self._height = height
else:
self._height = Window._default_height
if caption is None:
caption = sys.argv[0]
self._caption = caption
self._saved_width = self._width
self._saved_height = self._height
if _window is None:
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE |
glut.GLUT_RGBA |
glut.GLUT_DEPTH)
self._window_id = glut.glutCreateWindow(self._caption)
glut.glutDisplayFunc(self._display)
glut.glutReshapeFunc(self._reshape)
glut.glutKeyboardFunc(self._keyboard)
glut.glutKeyboardUpFunc(self._keyboard_up)
glut.glutMouseFunc(self._mouse)
glut.glutMotionFunc(self._motion)
glut.glutPassiveMotionFunc(self._passive_motion)
glut.glutVisibilityFunc(self._visibility)
glut.glutEntryFunc(self._entry)
glut.glutSpecialFunc(self._special)
glut.glutSpecialUpFunc(self._special_up)
gl.glClearColor(0,0,0,0)
self._visible = visible
self._time = glut.glutGet(glut.GLUT_ELAPSED_TIME)
if not visible:
glut.glutHideWindow()
else:
glut.glutShowWindow()
self.set_size(self._width, self._height)
screen_width = glut.glutGet(glut.GLUT_SCREEN_WIDTH)
screen_height= glut.glutGet(glut.GLUT_SCREEN_HEIGHT)
glut.glutPositionWindow((screen_width-self._width)//2,
(screen_height-self._height)//2)
self.fullscreen = fullscreen
def initialize(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH)
glut.glutInitWindowSize(self.width,self.height)
glut.glutInitWindowPosition(300,300)
glut.glutCreateWindow("super black hole sunshine party")
glut.glutDisplayFunc(self.paintGL)
glut.glutIdleFunc(self.paintGL)
glut.glutReshapeFunc(self.resizeGL)
self.initGL()
self.inputHandler.attachGLUT()
glut.glutMainLoop()
def init_window(self):
glut.glutInit(sys.argv)
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_ALPHA | glut.GLUT_DEPTH)
glut.glutInitWindowPosition(
(glut.glutGet(glut.GLUT_SCREEN_WIDTH) - self.window_width) // 2,
(glut.glutGet(glut.GLUT_SCREEN_HEIGHT) - self.window_height) // 2,
)
glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_CONTINUE_EXECUTION)
glut.glutInitWindowSize(self.window_width, self.window_height)
self.window_handle = glut.glutCreateWindow(WINDOW_TITLE_PREFIX)
glut.glutDisplayFunc(self.render_func)
glut.glutReshapeFunc(self.resize_func)
glut.glutMouseFunc(self.mouse)
glut.glutMotionFunc(self.mouse_motion)
glut.glutKeyboardFunc(self.keyboard)
glut.glutSpecialFunc(self.keyboard_s)
def __init__(self, name='glut window', *args, **kwargs):
BaseCanvasBackend.__init__(self)
self._id = glut.glutCreateWindow(name)
global ALL_WINDOWS
ALL_WINDOWS.append(self)
# Cache of modifiers so we can send modifiers along with mouse motion
self._modifiers_cache = ()
# Note: this seems to cause the canvas to ignore calls to show()
# about half of the time.
# glut.glutHideWindow() # Start hidden, like the other backends
# 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 function. See issue #10. For some reason, the function
# can still not exist even if we checked its boolean status.
closeFuncSet = False
if bool(glut.glutWMCloseFunc): # OSX specific test
try:
glut.glutWMCloseFunc(self.on_close)
closeFuncSet = True
except OpenGL.error.NullFunctionError:
pass
if not closeFuncSet:
try:
glut.glutCloseFunc(self.on_close)
closeFuncSet = True
except OpenGL.error.NullFunctionError:
pass
# glut.glutFunc(self.on_)
self._initialized = False
# LC: I think initializing here makes it more consistent with other
# backends
glut.glutTimerFunc(0, self._emit_initialize, None)
def interaction(self):
glut.glutDisplayFunc(self.disp)
glut.glutReshapeFunc(self.resh)
glut.glutKeyboardFunc(self.key)
transl_scale,rotation_scale=self.mouse_scale
self.mouse=mouse.MouseInteractor(transl_scale,rotation_scale)
#registers both glutMouseFunc and glutMotionFunc
self.mouse.registerCallbacks()
if self.autostart_timer1:
glut.glutTimerFunc(self.timer1Dt,self.timer1,1)
if self.autostart_timer2:
glut.glutTimerFunc(self.timer2Dt,self.timer2,1)
def __init__(
self,
update_callback = _EmptyOneArgCallback,
display_callback = _EmptyZeroArgCallback,
init_callback = _EmptyZeroArgCallback,
key_callback = _EmptyThreeArgCallback,
window_name = 'viewer',
window_size = (640, 480),
frame_rate = 60,
clear_color = (0.0, 0.0, 0.0, 1.0),
field_of_view = 45.0,
):
self.update_callback = update_callback
self.display_callback = display_callback
self.key_callback = key_callback
self.ms_per_frame = int(1000.0 / frame_rate)
self.field_of_view = field_of_view
GLUT.glutInit()
GLUT.glutInitWindowSize(*window_size)
GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGB | GLUT.GLUT_DEPTH)
GLUT.glutCreateWindow(window_name)
GLUT.glutDisplayFunc(self.Display)
GLUT.glutKeyboardFunc(self.Key)
GLUT.glutReshapeFunc(self.Reshape)
GLUT.glutMouseFunc(self.Mouse)
GLUT.glutMotionFunc(self.Motion)
GLUT.glutPassiveMotionFunc(self.PassiveMotion)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL)
GL.glClearColor(*clear_color)
self.Reshape(*window_size)
self.camera_theta = 0.0
self.camera_phi = 0.0
self.camera_r = 10.0
self.camera_center = numpy.array((0.0, 0.0, 0.0))
self.UpdateCameraRotationMatrix()
self.mouse_drag_mode = None
init_callback()
def init_glut(self, args):
"""Initialize the GLUT state."""
# Initialize GLUT.
GLUT.glutInit(args)
GLUT.glutInitContextVersion(
self.context_version[0], self.context_version[1])
GLUT.glutInitContextFlags(GLUT.GLUT_FORWARD_COMPATIBLE)
GLUT.glutInitContextProfile(GLUT.GLUT_CORE_PROFILE)
GLUT.glutSetOption(
GLUT.GLUT_ACTION_ON_WINDOW_CLOSE,
GLUT.GLUT_ACTION_GLUTMAINLOOP_RETURNS)
# Initialize and create the main window.
GLUT.glutInitDisplayMode(
GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH)
GLUT.glutInitWindowSize(
self.window_size[0], self.window_size[1])
GLUT.glutInitWindowPosition(
self.window_position[0], self.window_position[1])
GLUT.glutCreateWindow(self.window_title)
GLUT.glutDisplayFunc(self.render)
GLUT.glutIdleFunc(self.idle)
GLUT.glutReshapeFunc(self.resize)
GLUT.glutKeyboardFunc(self.keyboard)
GLUT.glutTimerFunc(0, self.timer, 0)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.motion)
GLUT.glutCloseFunc(self.cleanup)
aspects = [('Vendor', GL.GL_VENDOR),
('Renderer', GL.GL_RENDERER),
('Version', GL.GL_VERSION),]
if self.context_version[0] > 1:
aspects.append(('GLSL', GL.GL_SHADING_LANGUAGE_VERSION))
for i in aspects:
print('{}: {}'.format(i[0],
GL.glGetString(i[1]).decode()),
file=sys.stderr, flush=True)
def run(self):
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE
| glut.GLUT_ALPHA | glut.GLUT_DEPTH)
glut.glutInitWindowSize(self.window_width, self.window_height)
self.window = glut.glutCreateWindow("Point cloud test")
glut.glutDisplayFunc(self.display_base)
glut.glutIdleFunc(self.display_base)
glut.glutReshapeFunc(self.resize_event)
glut.glutKeyboardFunc(self.keyboard_press_event)
glut.glutKeyboardUpFunc(self.keyboard_up_event)
glut.glutMouseFunc(self.mouse_button_event)
glut.glutMotionFunc(self.mouse_moved_event)
self.init_gl(self.window_width, self.window_height)
glut.glutMainLoop()
def main(self, neuronObject, displaysize=(800, 600), radius=5, poly=True,
fast=False, multisample=True, graph=True):
self.poly = poly
self.displaysize = displaysize
self.graph = graph
title = 'btmorph OpenGL Viewer'
GLUT.glutInit(sys.argv)
if multisample:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE)
else:
GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA |
GLUT.GLUT_DOUBLE |
GLUT.GLUT_MULTISAMPLE)
GLUT.glutInitWindowSize(self.displaysize[0], self.displaysize[1])
GLUT.glutInitWindowPosition(50, 50)
GLUT.glutCreateWindow(title)
GLUT.glutDisplayFunc(self.display)
GLUT.glutReshapeFunc(self.reshape)
GLUT.glutMouseFunc(self.mouse)
GLUT.glutMotionFunc(self.mouseMove)
GLUT.glutMouseWheelFunc(self.mouseWheel)
GLUT.glutKeyboardFunc(self.keyDown)
GLUT.glutKeyboardUpFunc(self.keyUp)
mb = modelbuilder()
self.root, self.vertices_gl, self.colors_gl, self.Neuron = \
mb.build(neuronObject, self.poly, 100, fast)
if graph:
self.gb = graphbuilder()
self.Graph, mid = \
self.gb.build(neuronObject, scalefactor=100)
self.initGL(multisample)
self.camera.rad = radius
self.camera.focus = mid
while self.running:
GLUT.glutMainLoopEvent()
GLUT.glutDestroyWindow(GLUT.glutGetWindow())
def init(self, w=None, h=None):
if w: self.width = w
if h: self.height = h
try:
glut.glutInit()
except Exception as e:
print(e)
sys.exit()
if pl.system() == 'Darwin': #Darwin: OSX
glut.glutInitDisplayString('double rgba samples=8 core depth')
else: #Other: Linux
try:
glut.glutInitDisplayMode(
glut.GLUT_DOUBLE | \
glut.GLUT_RGBA | \
glut.GLUT_MULTISAMPLE | \
glut.GLUT_DEPTH)
except Exception as e:
print('Issue detected')
print(e)
sys.exit()
glut.glutInitWindowSize (self.width, self.height)
glut.glutCreateWindow (self.label)
self.handler.init()
glut.glutDisplayFunc(self.display)
glut.glutKeyboardFunc(self.on_key_press)
glut.glutMouseFunc(self.on_mouse_click)
glut.glutMotionFunc(self.on_mouse_motion)
glut.glutPassiveMotionFunc(self.on_mouse_motion)
glut.glutReshapeFunc(self.on_resize)
self.last_glut_idle_time = time.time()
glut.glutIdleFunc(self.on_glut_idle)
if self.streamed:
# sakura core defines the main program loop,
# so we have to run GLUT's own loop in another
# greenlet.
self.spawn_greenlet_loop()
def __init__( self, mesh, width=1024, height=768 ) : # Initialise OpenGL / GLUT glut.glutInit() glut.glutInitDisplayMode( glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH | glut.GLUT_MULTISAMPLE ) glut.glutInitWindowSize( width, height ) glut.glutInitWindowPosition( 100, 100 ) glut.glutCreateWindow( mesh.name ) # Mesh viewer self.meshviewer = mtk.MeshViewer() self.meshviewer.InitialiseOpenGL( width, height ) self.meshviewer.LoadMesh( mesh ) self.antialiasing = True # GLUT function binding glut.glutCloseFunc( self.meshviewer.Close ) glut.glutDisplayFunc( self.Display ) glut.glutIdleFunc( self.Idle ) glut.glutKeyboardFunc( self.Keyboard ) glut.glutMouseFunc( self.Mouse ) glut.glutMotionFunc( self.meshviewer.trackball.MouseMove ) glut.glutReshapeFunc( self.meshviewer.Resize )
