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 __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 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, *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 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 __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 __glInit(self): self.initTime = time.time() glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB) glut.glutInitWindowSize(1000, 1000) glut.glutInitWindowPosition(50, 50) glut.glutInit([]) glut.glutCreateWindow(b"OpenGL Fractal Renderer") self.gpu_vendor = gl_v1.glGetString(gl.GL_VENDOR).decode("ascii") self.gpu_model = gl_v1.glGetString(gl.GL_RENDERER).decode("ascii") self.gpu_attrib_count = gl.glGetInteger(gl.GL_MAX_VERTEX_ATTRIBS) print(f"Found {self.gpu_vendor} {self.gpu_model}") print(f"GPU supports {self.gpu_attrib_count} vertex attributes") self.shaderProgram = gl.glCreateProgram() self.shaderVertex = self.__glCreateShader( gl.GL_VERTEX_SHADER, """ #version 410 layout(location = 0) in vec4 vertexPosition; //[0] - centerX, [1] - centerY, [2] - scaleH, [3] - width / height layout(location = 1) in vec4 centerAndScale; out mat2 pos; void main() { gl_Position = vertexPosition; float x = centerAndScale[0] + vertexPosition[0] / 2.0 * centerAndScale[2] * centerAndScale[3]; float y = centerAndScale[1] + vertexPosition[1] / 2.0 * centerAndScale[2] ; pos = mat2(x,y,-y,x); } """) self.shaderSourceGenerator = GLFractalSourceGenerator() self.shaderSourceGenerator.generateSource(self.fractal) self.shaderSource = self.shaderSourceGenerator.getOneSourceString() self.shaderFragment = self.__glCreateFragmentShader(self.shaderSource) self.shaderSourceGenerator.printSource() gl.glAttachShader(self.shaderProgram, self.shaderVertex) gl.glAttachShader(self.shaderProgram, self.shaderFragment) gl.glLinkProgram(self.shaderProgram) linkStatus = gl.glGetProgramiv(self.shaderProgram, gl.GL_LINK_STATUS) if linkStatus != gl.GL_TRUE: error = gl.glGetProgramInfoLog(self.shaderProgram).decode("ascii") raise GLShaderLinkError(error) gl.glUseProgram(self.shaderProgram) self.__glSetupVarloc() glut.glutSpecialFunc(self.__glutSpecialKeyHandler) glut.glutDisplayFunc(self.__glDraw) glut.glutIdleFunc(self.__glDraw) 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 __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 attachGLUT(self): glut.glutMouseFunc(self.mouseInputHandler) glut.glutMouseWheelFunc(self.mouseWheelHandler) glut.glutMotionFunc(self.mouseMoveHandler) glut.glutPassiveMotionFunc(self.mouseMoveHandler) glut.glutKeyboardFunc(self.keyboardHandler) glut.glutKeyboardUpFunc(lambda *x:self.keyboardHandler(*x,isEnd=True)) glut.glutSpecialFunc(self.specialKeyHandler) glut.glutSpecialUpFunc(lambda *x:self.specialKeyHandler(*x,isEnd=True))
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 _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, 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 attachGLUT(self): glut.glutMouseFunc(self.mouseInputHandler) glut.glutMouseWheelFunc(self.mouseWheelHandler) glut.glutMotionFunc(self.mouseMoveHandler) glut.glutPassiveMotionFunc(self.mouseMoveHandler) glut.glutKeyboardFunc(self.keyboardHandler) glut.glutKeyboardUpFunc( lambda *x: self.keyboardHandler(*x, isEnd=True)) glut.glutSpecialFunc(self.specialKeyHandler) glut.glutSpecialUpFunc( lambda *x: self.specialKeyHandler(*x, isEnd=True))
def __init__(self,*args,**kwargs): oglut.glutInit(sys.argv) oglut.glutInitDisplayMode(oglut.GLUT_RGBA | oglut.GLUT_DOUBLE | oglut.GLUT_DEPTH) oglut.glutInitWindowSize(800, 480) self.window = oglut.glutCreateWindow(b"window") oglut.glutDisplayFunc(self.display) #oglut.glutIdleFunc(self.display) oglut.glutReshapeFunc(self.resize) oglut.glutKeyboardFunc(self.on_keyboard) oglut.glutSpecialFunc(self.on_special_key) oglut.glutMouseFunc(self.on_mouse) oglut.glutMotionFunc(self.on_mousemove) self.controller = None self.update_if = oglut.glutPostRedisplay
def main(): print("-----------------------------------------------------------") print("Alternar entre Fill e Wireframe: 'v'") print("Modo Translação: 't'") print("\t → : deslocamento positivo em X") print("\t ← : deslocamento negativo em X") print("\t ↑ : deslocamento positivo em Y") print("\t ↓ : deslocamento negativo em Y") print("\t'a' : deslocamento positivo em Z") print("\t'd' : deslocamento negativo em Z") print("Modo Rotação: 'r'") print("\t ↑ : rotação positivo em X") print("\t ↓ : rotação negativo em X") print("\t → : rotação positivo em Y") print("\t ← : rotação negativo em Y") print("\t'a' : rotação positivo em Z") print("\t'd' : rotação negativo em Z") print("Modo Escala: 'e'") print("\t → : fator positivo em X") print("\t ← : fator negativo em X") print("\t ↑ : fator positivo em Y") print("\t ↓ : fator negativo em Y") print("\t'a' : fator positivo em Z") print("\t'd' : fator negativo em Z") print("-----------------------------------------------------------") glut.glutInit() glut.glutInitContextVersion(3, 3); glut.glutInitContextProfile(glut.GLUT_CORE_PROFILE); glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH) glut.glutInitWindowSize(win_width, win_height) glut.glutCreateWindow('Trabalho 2') # Init vertex data for the triangle. initData() # Create shaders. initShaders() glut.glutReshapeFunc(reshape) glut.glutDisplayFunc(display) glut.glutKeyboardFunc(keyboard) glut.glutIdleFunc(idle); glut.glutSpecialFunc(SpecialInput) 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 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) # Drawing Function GLUT.glutDisplayFunc(draw) # Input Functions GLUT.glutSpecialFunc(special_key_pressed) GLUT.glutKeyboardFunc(key_pressed) GLUT.glutMouseFunc(mouse_click) GLUT.glutMotionFunc(mouse_move) load_textures() GL.glEnable(GL.GL_MULTISAMPLE) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_TEXTURE_2D) GL.glClearColor(*background_color) GL.glClearDepth(1.0) GL.glDepthFunc(GL.GL_LESS) GL.glShadeModel(GL.GL_SMOOTH) GL.glMatrixMode(GL.GL_PROJECTION) # Pre-render camera positioning GLU.gluPerspective(-45, window_width / window_height, 0.1, 100.0) GL.glTranslatef(0.0, 0.0, -10) GL.glMatrixMode(GL.GL_MODELVIEW) GLUT.glutTimerFunc(10, timer, 1) GLUT.glutMainLoop()
def main(self): """Main function responsible for run the game.""" glut.glutInit(sys.argv) # 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(1000, 800) # the window starts at the upper left corner of the screen glut.glutInitWindowPosition(0, 0) # Asign name of the window glut.glutCreateWindow("PacMan") # Register the function called when the keyboard is pressed. glut.glutKeyboardFunc(self.key_pressed) glut.glutSpecialFunc(self.key_pressed_special) glut.glutSpecialUpFunc(self.key_pressed_special_up) # Register the drawing function with glut. glut.glutDisplayFunc(self.draw_scene) # Uncomment this line to get full screen. # glut.glutFullScreen() # When we are doing nothing, redraw the scene. glut.glutIdleFunc(self.draw_scene) # Register the function called when our window is resized. glut.glutReshapeFunc(self.re_size_gl_scene) # Initialize our window. self.init_gl(640, 480) # Start Event Processing Engine glut.glutMainLoop()
def init(): GLUT.glutInit() #GLUT.glutInitDisplayMode(GLUT.GLUT_RGB | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH) GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_ALPHA | GLUT.GLUT_DEPTH) GLUT.glutInitWindowSize(width, height) # the window starts at the upper left corner of the screen GLUT.glutInitWindowPosition(0, 0) window = GLUT.glutCreateWindow(winName) GLUT.glutDisplayFunc(DrawGLScene) # Uncomment this line to get full screen. #glutFullScreen() # When we are doing nothing, redraw the scene. GLUT.glutIdleFunc(DrawGLScene) GLUT.glutReshapeFunc(resizeWindow) GLUT.glutKeyboardFunc(keyPressed) GLUT.glutSpecialFunc(keyPressed)
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 main(filepath, texpath): glut.glutInit() glut.glutInitContextVersion(3, 3) glut.glutInitContextProfile(glut.GLUT_CORE_PROFILE) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH) glut.glutInitWindowSize(win_width,win_height) glut.glutCreateWindow('M E S H') initData(filepath, texpath) initShaders() glut.glutReshapeFunc(reshape) glut.glutDisplayFunc(display) glut.glutKeyboardFunc(keyboard) glut.glutSpecialFunc(special_keyboard) glut.glutIdleFunc(idle) glut.glutMainLoop()
def start(self): """ Запуск """ GLUT.glutInit([]) # Инициализация библиотеки GLUT buffering = GLUT.GLUT_SINGLE # Вариант буферизации color_model = GLUT.GLUT_RGB # Вариант цветовой модели # Инициализация отображения в нужном режимах GLUT.glutInitDisplayMode(buffering | color_model | GLUT.GLUT_DEPTH) GLUT.glutInitWindowSize(self.window_width, self.window_height) # Размер окна GLUT.glutInitWindowPosition(self.move_window_x, self.move_window_y) # Позиция окна GLUT.glutCreateWindow( self.window_name) # Создание окна с указанным именем GLUT.glutDisplayFunc( self.__draw) # Отображение изображения (перерисовка окна) GLUT.glutIdleFunc( self.__draw ) # Вызывается системой всякий раз, когда приложение простаивает GLUT.glutReshapeFunc(self.__resize) # Изменение размеров окна # Обработка нажатий на клавиатуру (клавиша Escape) GLUT.glutKeyboardFunc(self.__keyboard) GLUT.glutSpecialFunc( self.__keyboard) # Обработка нажатий на клавиатуру GL.glClearColor(0.0, 0.0, 0.0, 1.0) GL.glEnable(GL.GL_DEPTH_TEST) GL.glMatrixMode( GL.GL_PROJECTION ) # Применять матричные операции к стеку проекционных матриц GL.glLoadIdentity() # Единичная матрица GL.glOrtho(-1, 1, -1, 1, -1, 1) # Умножение текущей матрицы на ортографическую матрицу GLUT.glutMainLoop() # Цикл обработки событий GLUT
def __init__(self, scene): """Sets up the core functionality we need to begin rendering. This includes the OpenGL configuration, the window, the viewport, the event handler and update loop registration. """ super(Application, self).__init__(scene) if self.scene.core_profile: raise ValueError("GLUT does not support Core profile") # glut initialization GLUT.glutInit(sys.argv) GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH) # set the window's dimensions GLUT.glutInitWindowSize(1024, 768) # set the window caption # create our window GLUT.glutCreateWindow("PyGLy - GLUT - " + scene.name) # print some opengl information pygly.gl.print_gl_info() # create the scene now that we've got our window open self.scene.initialise() self.last_time = time() # set the function to draw GLUT.glutReshapeFunc(self.on_window_resized) GLUT.glutIdleFunc(self.idle) GLUT.glutDisplayFunc(self.render) GLUT.glutKeyboardFunc(self.on_key_pressed) GLUT.glutKeyboardUpFunc(self.on_key_released) GLUT.glutSpecialFunc(self.on_special_key_pressed) GLUT.glutSpecialUpFunc(self.on_special_key_released)
def main(): GLUT.glutInit(argv) GLUT.glutInitDisplayMode( GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH | GLUT.GLUT_MULTISAMPLE ) 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) GLUT.glutDisplayFunc(draw) GLUT.glutSpecialFunc(special_key_pressed) GLUT.glutKeyboardFunc(key_pressed) GLUT.glutMouseFunc(mouse_click) GLUT.glutMotionFunc(mouse_move) GL.glEnable(GL.GL_MULTISAMPLE) GL.glEnable(GL.GL_DEPTH_TEST) GL.glClearColor(*background_color) GLU.gluPerspective(-45, window_width / window_height, 0.1, 100.0) GL.glTranslatef(0.0, 0.0, -10) GLUT.glutTimerFunc(10, timer, 1) GLUT.glutMainLoop()
def __init__( self, scene ): """Sets up the core functionality we need to begin rendering. This includes the OpenGL configuration, the window, the viewport, the event handler and update loop registration. """ super( Application, self ).__init__( scene ) if self.scene.core_profile: raise ValueError( "GLUT does not support Core profile" ) # glut initialization GLUT.glutInit( sys.argv ) GLUT.glutInitDisplayMode( GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH ) # set the window's dimensions GLUT.glutInitWindowSize( 1024, 768 ) # set the window caption # create our window GLUT.glutCreateWindow( "PyGLy - GLUT - " + scene.name ) # print some opengl information pygly.gl.print_gl_info() # create the scene now that we've got our window open self.scene.initialise() self.last_time = time() # set the function to draw GLUT.glutReshapeFunc( self.on_window_resized ) GLUT.glutIdleFunc( self.idle ) GLUT.glutDisplayFunc( self.render ) GLUT.glutKeyboardFunc( self.on_key_pressed ) GLUT.glutKeyboardUpFunc( self.on_key_released ) GLUT.glutSpecialFunc( self.on_special_key_pressed ) GLUT.glutSpecialUpFunc( self.on_special_key_released )
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)
def main() : global tetris tetris = Tetris() _ = glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH) glut.glutInitWindowSize(600, 600) glut.glutInitWindowPosition(0, 100) _ = glut.glutCreateWindow('Tetris!!!') init() _ = glut.glutDisplayFunc(display) _ = glut.glutReshapeFunc(reshape) _ = glut.glutKeyboardFunc(keyboard) _ = glut.glutIdleFunc(idle) _ = glut.glutMotionFunc(mouse) _ = glut.glutSpecialFunc(special) glut.glutMainLoop()
def start(self): GLUT.glutIgnoreKeyRepeat(True) GLUT.glutSpecialFunc(self.special_keyboard_down) GLUT.glutSpecialUpFunc(self.special_keyboard_up)
def handle_special_keypress(key, x, y): if key == GLUT_KEY_LEFT and not camera.position.x == 24: camera.position += glm.vec3(10.0, 0.0, 0.0) if key == GLUT_KEY_RIGHT and not camera.position.x == -26: camera.position -= glm.vec3(10.0, 0.0, 0.0) if key == GLUT_KEY_UP and not camera.position.y == 60: camera.position += glm.vec3(0.0, 10.0, 0.0) if key == GLUT_KEY_DOWN and not camera.position.y == 0: camera.position -= glm.vec3(0.0, 10.0, 0.0) glut.glutKeyboardUpFunc(keyboard_up_input) glut.glutSpecialFunc(handle_special_keypress) def keyboard_input(key, x, y): pressed_keys.add(key) if key == b'-': player.scale -= glm.vec3(0.1) player.scaling(player.scale) if key == b'+': player.scale += glm.vec3(0.1) player.scaling(player.scale) if key == b'r': ball.position = glm.vec3(-5, 0, -10)
doc='glutInitDisplayString( ) -> None', argNames=()) text = ctypes.c_char_p("rgba stencil double samples=8 hidpi") glutInitDisplayString(text) except: pass glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH) glut.glutInitWindowSize(1000, 1000) glut.glutCreateWindow( "Dashed & antialiased bezier curve [Arrow keys change offset]") glut.glutDisplayFunc(on_display) glut.glutReshapeFunc(on_reshape) glut.glutKeyboardFunc(on_keyboard) glut.glutSpecialFunc(on_special) # Some init gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glDisable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_BLEND) gl.glClearColor(1.0, 1.0, 1.0, 1.0) u_projection = np.eye(4).astype(np.float32) u_view = np.eye(4).astype(np.float32) u_model = np.eye(4).astype(np.float32) collection = DashLines() # --------------------------------- points = np.array([[.1, .6], [.5, 1.], [.9, .6]]) vertices = curve3_bezier(*points)
global deltaMove if key == glut.GLUT_KEY_UP: deltaMove = 0.5 elif key == glut.GLUT_KEY_DOWN: deltaMove = -0.5 # ------------------------------------------------------- def releaseKey(key, xx, yy): global deltaMove deltaMove = 0 # ------------------------------------------------------- # main program init glut.glutInit() glut.glutInitWindowSize(800, 600) glut.glutInitDisplayMode(glut.GLUT_RGB | glut.GLUT_DOUBLE | glut.GLUT_DEPTH) glut.glutCreateWindow("DynSimTest") glut.glutDisplayFunc(render) glut.glutIdleFunc(simulate) glut.glutMouseFunc(mouseButton) glut.glutMotionFunc(mouseMove) glut.glutSpecialFunc(pressKey) glut.glutSpecialUpFunc(releaseKey) init() glut.glutMainLoop()
# game_state.modify('right') # glut.glutPostRedisplay() # elif key == glut.GLUT_KEY_UP: # game_state.modify('up') # glut.glutPostRedisplay() # elif key == glut.GLUT_KEY_DOWN: # game_state.modify('down') # glut.glutPostRedisplay() pass task_spec = json.loads(open(sys.argv[1]).read()) units = list(lib._unit_generator( task_spec['sourceSeeds'][0], task_spec['units'], limit=task_spec['sourceLength'])) init_board = lib.Board(task_spec['width'], task_spec['height'], task_spec['filled']) game_state = lib.InitState(init_board, units) glut.glutInit() glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA) glut.glutCreateWindow('Honeycomb board visualisation') glut.glutReshapeWindow(800,800) glut.glutReshapeFunc(reshape) glut.glutDisplayFunc(display) glut.glutKeyboardFunc(keyboard) glut.glutSpecialFunc(special_input) glut.glutMainLoop()
def __init__(self, size=None, position=None, title=None, fullscreen=False,enableAlpha=True,pointSize=2): ''' Constructor ''' self._mouse_x = 0 self._mouse_y = 0 self._button = mouse.NONE self._modifiers = None self._motionEventCounter=0 self._time = None self._timer_stack = [] self._timer_date = [] self._title = title or "PyGLer" # FIXME: get default name from a central location self._fullscreen = -1 self.dragSensitivity = 5 # Is there any glut loop already running ? if glut.glutGetWindow( ) == 0: glut.glutInit() glut.glutInitDisplayMode( glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH ) self._interactive = False else: self._interactive = True self._id = glut.glutCreateWindow( self._title ) glut.glutShowWindow() glut.glutDisplayFunc( self.redraw ) 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.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_BLEND) if enableAlpha: GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); GL.glPolygonOffset(1, 1); GL.glEnable(GL.GL_POLYGON_OFFSET_FILL); GL.glPointSize(pointSize) GL.glEnable(GL.GL_PROGRAM_POINT_SIZE) if size is not None: width, height = size glut.glutReshapeWindow( width, height ) width = glut.glutGet( glut.GLUT_WINDOW_WIDTH ) height= glut.glutGet( glut.GLUT_WINDOW_HEIGHT ) self._width = width self._height = height if position is not None: x,y = position glut.glutPositionWindow( x, y ) x = glut.glutGet( glut.GLUT_WINDOW_X ) y = glut.glutGet( glut.GLUT_WINDOW_X ) self._x, self._y = x, y # These ones will be used when exiting fullscreen self._saved_width = self._width self._saved_height = self._height self._saved_x = self._x self._saved_y = self._y self._time = glut.glutGet( glut.GLUT_ELAPSED_TIME ) self._fullscreen = fullscreen if fullscreen: self.set_fullscreen(True)
def tiny_glut(args): global vertex_code, fragment_code scale = 0.01 def display(): CAMERA.render() gl.glClear(gl.GL_COLOR_BUFFER_BIT) nonlocal scale scale_location = gl.glGetUniformLocation(program, "gScale") assert scale_location != 0xffffffff world_location = gl.glGetUniformLocation(program, "gWorld") assert world_location != 0xffffffff scale += 0.01 pipeline = Pipeline(rotation=[0.0, 30*scale, 0.0], # scaling=[math.sin(scale)] * 3, translation=[0, 0, 6], projection=ProjParams(WINDOW_WIDTH, WINDOW_HEIGHT, 1.0, 100.0, 60.0)) pipeline.set_camera(CAMERA) gl.glUniformMatrix4fv(world_location, 1, gl.GL_TRUE, pipeline.get_wvp()) gl.glDrawElements(gl.GL_TRIANGLES, 18, gl.GL_UNSIGNED_INT, ctypes.c_void_p(0)) glut.glutSwapBuffers() # glut.glutPostRedisplay() def mouse(x, y): CAMERA.mouse(x, y) def keyboard(key, x, y): if key == glut.GLUT_KEY_F1: sys.exit(0) elif key == glut.GLUT_KEY_HOME: CAMERA.setup() else: CAMERA.keyboard(key) glut.glutInit(args) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_3_2_CORE_PROFILE) glut.glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT) glut.glutInitWindowPosition(400, 100) # glut.glutCreateWindow("Camera Tutorial") glut.glutGameModeString("1920x1200@32") glut.glutEnterGameMode() # callbacks initialization glut.glutDisplayFunc(display) glut.glutIdleFunc(display) # glut.glutKeyboardFunc(keyboard) glut.glutPassiveMotionFunc(mouse) glut.glutSpecialFunc(keyboard) gl.glEnable(gl.GL_DEPTH_TEST) gl.glDepthFunc(gl.GL_LESS) gl.glClearColor(0, 0, 0, 0) vertices = np.array([ -1, -1, 0, 0, -1, -1, 1, -1, 0, 0, -1, 1, 0, 1, 0 ], dtype=np.float32) indexes = np.array([ 0, 1, 2, 1, 2, 3, 0, 1, 4, 1, 2, 4, 2, 3, 4, 3, 0, 4 ], dtype=np.uint32) vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER) gl.glShaderSource(vertex_shader, vertex_code) gl.glCompileShader(vertex_shader) if not gl.glGetShaderiv(vertex_shader, gl.GL_COMPILE_STATUS): info = gl.glGetShaderInfoLog(vertex_shader) print("vertex shader error occurred") print(bytes.decode(info)) return fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) gl.glShaderSource(fragment_shader, fragment_code) gl.glCompileShader(fragment_shader) if not gl.glGetShaderiv(fragment_shader, gl.GL_COMPILE_STATUS): info = gl.glGetShaderInfoLog(fragment_shader) print("fragment shader error occurred") print(bytes.decode(info)) return program = gl.glCreateProgram() gl.glAttachShader(program, vertex_shader) gl.glAttachShader(program, fragment_shader) gl.glLinkProgram(program) gl.glUseProgram(program) vao = gl.glGenVertexArrays(1) gl.glBindVertexArray(vao) vbo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo) gl.glBufferData(gl.GL_ARRAY_BUFFER, vertices.nbytes, vertices, gl.GL_STATIC_DRAW) gl.glEnableVertexAttribArray(0) gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 0, ctypes.c_void_p(0)) ibo = gl.glGenBuffers(1) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ibo) gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indexes.nbytes, indexes, gl.GL_STATIC_DRAW) glut.glutMainLoop()
def __init__( self, size=None, position=None, title=None, fullscreen=False): ''' Create a window with given sise, position and title. :param (int,int) size: Initial window size as (width,height) in pixels. :param (int,int) position: Initial window position. Depending on the window-manager, the position request may or may not be honored. :param string title: The title of the window. ''' global _window window.Window.__init__( self, size, position, title ) self._mouse_x = 0 self._mouse_y = 0 self._button = mouse.NONE self._modifiers = None self._time = None self._timer_stack = [] self._timer_date = [] self._title = title or sys.argv[0] self._fullscreen = -1 # Is there any glut loop already running ? if glut.glutGetWindow( ) == 0: glut.glutInit( sys.argv ) glut.glutInitDisplayMode( glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH ) self._interactive = False else: self._interactive = True self._id = glut.glutCreateWindow( self._title ) glut.glutShowWindow( ) 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 ) if size is not None: width, height = size glut.glutReshapeWindow( width, height ) width = glut.glutGet( glut.GLUT_WINDOW_WIDTH ) height= glut.glutGet( glut.GLUT_WINDOW_HEIGHT ) self._width = width self._height = height if position is not None: x,y = position glut.glutPositionWindow( x, y ) #else: # screen_width = glut.glutGet( glut.GLUT_SCREEN_WIDTH ) # screen_height= glut.glutGet( glut.GLUT_SCREEN_HEIGHT ) # x = (screen_width - self._size[0]) / 2 # y = (screen_width - self._size[0]) / 2 # glut.glutPositionWindow( x, y ) x = glut.glutGet( glut.GLUT_WINDOW_X ) y = glut.glutGet( glut.GLUT_WINDOW_X ) self._x, self._y = x, y # These ones will be used when exiting fullscreen self._saved_width = self._width self._saved_height = self._height self._saved_x = self._x self._saved_y = self._y self._time = glut.glutGet( glut.GLUT_ELAPSED_TIME ) _window = self self._fullscreen = False if fullscreen: self.set_fullscreen(True)
glut.glutPostRedisplay() if __name__ == '__main__': import sys import OpenGL.GLUT as glut from glagg import PathCollection glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB) glut.glutCreateWindow("Line joins") glut.glutReshapeWindow(512, 512) glut.glutDisplayFunc(on_display) glut.glutReshapeFunc(on_reshape) glut.glutKeyboardFunc(on_keyboard) glut.glutSpecialFunc(on_special) vertices = np.array( [(-0.50,-0.125), (-0.25,+0.125), (+0.00,-0.125), (+0.25,+0.125), (+0.50,-0.125) ] ) collection = PathCollection() collection.append(vertices, linewidth = 40, linejoin = 'miter', linecaps= ('<','>'), scale = 300, translate = (256,128) ) collection.append(vertices, linewidth = 40, linejoin = 'round', linecaps= ('(',')'), scale = 300, translate = (256,256) ) collection.append(vertices, linewidth = 40, linejoin = 'bevel', linecaps= ('=','='),
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()