def InitPyGame(): GLUT.glutInit(()) pygame.init() disp_no = os.getenv("DISPLAY") if disp_no: print "I'm running under X display = {0}".format(disp_no) drivers = ['fbcon', 'directfb', 'svgalib'] found = False for driver in drivers: if not os.getenv('SDL_VIDEODRIVER'): os.putenv('SDL_VIDEODRIVER', driver) try: pygame.display.init() except pygame.error: print 'Driver: {0} failed.'.format(driver) continue found = True break if not found: raise Exception('No suitable video driver found!') size = (pygame.display.Info().current_w, pygame.display.Info().current_h) print "Framebuffer size: %d x %d" % (size[0], size[1]) if config.full_screen: s = pygame.display.set_mode(size, locals.DOUBLEBUF | locals.OPENGL | locals.FULLSCREEN) else: s = pygame.display.set_mode(size, locals.DOUBLEBUF | locals.OPENGL) return s
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 __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): """ Initialize and create GLUT window """ glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA | glut.GLUT_DEPTH) glut.glutCreateWindow("OpenGL") glut.glutFullScreen() gl.glEnable(gl.GL_TEXTURE_2D) gl.glDisable(gl.GL_LIGHTING) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) gl.glEnableClientState(gl.GL_VERTEX_ARRAY) # Modify matrices for screen size width = glut.glutGet(glut.GLUT_SCREEN_WIDTH) height = glut.glutGet(glut.GLUT_SCREEN_HEIGHT) gl.glViewport(0, 0, width, height) gl.glMatrixMode(gl.GL_PROJECTION) aspect = width / height gl.glOrtho(-aspect, aspect, 1, -1, -1, 1) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity()
def initializeGL(self): GLUT.glutInit() try: self.bindBID = GL.glGenBuffers(1) # for streaming video except: print ('GL: no textures (failed glGenBuffers)') self.bindBID = 0
def main(): global _projection, _rotation, _time_dif, _aspect_ratio # OpenGL initialization. glut.glutInit(sys.argv) # Initialize buffer and OpenGL settings. glut.glutInitDisplayMode(glut.GLUT_SINGLE | glut.GLUT_RGB | glut.GLUT_DEPTH) init_window() # Initialize shaders. success = init_shaders() if not success: print('Failed to compile and link shader program.') # Initialize and create window, and set GLUT callback functions gl.glEnable(gl.GL_TEXTURE_2D) gl.glEnable(gl.GL_DEPTH_TEST) # gl.glEnable(gl.GL_LIGHTING) # TODO: Leave light disabled for now # gl.glShadeModel(gl.GL_SMOOTH) # # set display callback function glut.glutDisplayFunc(draw) # set mouse motion callback funciton # glut.glutPassiveMotionFunc(mouse_motion_handler) # set idle callback function # glut.glutIdleFunc(idle) # create perspective transformation matrix _projection = glm.perspective(glm.radians(45.0), _aspect_ratio, 0.1, 100.0) euler = glm.vec3(-45.0, 0.0, 0.0, dtype=c_float) _rotation = quat.tquat(euler, dtype=c_float) init_test_object() # _time_dif = datetime.now() _time_dif = time.time() # Begin main loop. glut.glutMainLoop()
def main(): global EVENT_MNGR, EVENT_DISP, EVENT_LIST,\ PROJECTION_MTRX, LOOKAT_MTRX, ASPECT_RATIO atexit.register(on_exit) glut.glutInit(sys.argv) OpenGL.GLUT.freeglut.glutSetOption(OpenGL.GLUT.GLUT_ACTION_ON_WINDOW_CLOSE, OpenGL.GLUT.GLUT_ACTION_GLUTMAINLOOP_RETURNS) init_window() EVENT_DISP = GloveletSensorEventDispatcher('/dev/ttyACM0', 115200) EVENT_LIST = GloveletDemoController() EVENT_MNGR = EventDispatchManager(EVENT_DISP, EVENT_LIST) init_hand() glut.glutShowWindow() # Init shaders if not init_shaders(): print('Failed to compile and link shader program.') # init OpenGL settings gl.glEnable(gl.GL_TEXTURE_2D) gl.glEnable(gl.GL_DEPTH_TEST) # set render callback glut.glutDisplayFunc(draw) glut.glutKeyboardFunc(keyboard_handler) # glut.glutPassiveMotionFunc(mouse_motion) # init perspective matrices PROJECTION_MTRX = glm.perspective(glm.radians(45.0), ASPECT_RATIO, 0.1, 100.0) LOOKAT_MTRX = glm.lookAt(glm.vec3((0.0, 2.0, -4.0), dtype='f'), # eye glm.vec3((0.0, 1.0, 0.0), dtype='f'), # center glm.vec3((0.0, 1.0, 0.0), dtype='f')) # up # begin main loop EVENT_MNGR.deploy_dispatchers() glut.glutMainLoop() EVENT_MNGR.end_dispatchers() exit()
def OnInit(self): import sys self.frame = mainWindow.MainWindow('OMX Editor v2.5') self.frame.Show() self.SetTopWindow(self.frame) if sys.platform == 'linux2': from OpenGL import GLUT GLUT.glutInit([]) ## in order to call Y.glutText() haveFilesToOpen = False for file in sys.argv[1:]: # When invoking this program as a standalone bundled app with # py2app, a bunch of junk we don't care about shows up on the # commandline, so only try to open a file if it actually exists. if os.path.exists(file): self.frame.openFile(file) haveFilesToOpen = True if not haveFilesToOpen: # Instead of just popping up a blank window, show an open-file # dialog. self.frame.OnFileOpen() return True
def main(): global calib, cyl src_dir = os.path.split(os.path.abspath(__file__))[0] data_dir = os.path.join(src_dir,'..','data') pmat = np.loadtxt( os.path.join(data_dir, 'cameramatrix.txt') ) calib = decompose(pmat) width = 752 height = 480 glut.glutInit() glut.glutInitWindowSize(width,height) glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DEPTH | glut.GLUT_ACCUM | glut.GLUT_DOUBLE) glut.glutCreateWindow("calib_test_pyopengl"); cyl = PointCylinder() if 1: # compose view matrix r = get_gluLookAt(pmat) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() glu.gluLookAt( *r['all_args'] ) gl.glDisable(gl.GL_DEPTH_TEST) glut.glutDisplayFunc(on_draw) on_resize(width,height) 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 initGLUT(vertex_shade_code, fragment_shader_code, texture_image): GLUT.glutInit(sys.argv) # argv,argcを渡す # 表示モード if texture_image.mode == 'RGB': GLUT.glutInitDisplayMode(GLUT.GLUT_RGB | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH) elif texture_image.mode == 'RGBA': GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH) else: # 謎のモード print(texture_image.mode) exit() window_width, window_height = texture_image.size # テクスチャサイズ = ウィンドウサイズ GLUT.glutInitWindowSize( window_width, window_height ) # the window starts at the upper left corner of the screen GLUT.glutInitWindowPosition(0, 0) GLUT.glutCreateWindow( sys.argv[0] ) ## The main drawing function. def draw(): GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) GL.glEnable( GL.GL_TEXTURE_2D ) GL.glDrawElements( GL.GL_TRIANGLES, 6, GL.GL_UNSIGNED_SHORT, np.array( indices, np.uint16 ) ) GL.glDisable(GL.GL_TEXTURE_2D) GLUT.glutSwapBuffers() GLUT.glutDisplayFunc(draw) GLUT.glutIdleFunc(drawGLScene) # When we are doing nothing, redraw the scene. initGL( vertex_shade_code, fragment_shader_code, texture_image ) # Initialize our window. GLUT.glutMainLoop() # Start Event Processing Engine
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 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 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 __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 main(): global calib, cyl src_dir = os.path.split(os.path.abspath(__file__))[0] data_dir = os.path.join(src_dir, '..', 'data') pmat = np.loadtxt(os.path.join(data_dir, 'cameramatrix.txt')) calib = decompose(pmat) width = 752 height = 480 glut.glutInit() glut.glutInitWindowSize(width, height) glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DEPTH | glut.GLUT_ACCUM | glut.GLUT_DOUBLE) glut.glutCreateWindow("calib_test_pyopengl") cyl = PointCylinder() if 1: # compose view matrix r = get_gluLookAt(pmat) gl.glMatrixMode(gl.GL_MODELVIEW) gl.glLoadIdentity() glu.gluLookAt(*r['all_args']) gl.glDisable(gl.GL_DEPTH_TEST) glut.glutDisplayFunc(on_draw) on_resize(width, height) 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 __init__(self, parent, devices, monitors, network): """Initialise canvas properties and useful variables.""" super().__init__(parent, -1, attribList=[ wxcanvas.WX_GL_RGBA, wxcanvas.WX_GL_DOUBLEBUFFER, wxcanvas.WX_GL_DEPTH_SIZE, 16, 0 ]) GLUT.glutInit() self.init = False self.context = wxcanvas.GLContext(self) # Initialise variables for panning self.pan_x = 0 self.pan_y = 0 self.last_mouse_x = 0 # previous mouse x position self.last_mouse_y = 0 # previous mouse y position self.devices = devices self.network = network self.monitors = monitors self.signals = [] # Initialise variables for zooming self.zoom = 1 # Bind events to the canvas self.Bind(wx.EVT_PAINT, self.on_paint) self.Bind(wx.EVT_SIZE, self.on_size) self.Bind(wx.EVT_MOUSE_EVENTS, self.on_mouse)
def InitGL( self ): gl.glMatrixMode(gl.GL_PROJECTION) # camera frustrum setup gl.glFrustum(-0.5, 0.5, -0.5, 0.5, 1, 10.0) gl.glMaterial(gl.GL_FRONT, gl.GL_AMBIENT, [0.2, 0.2, 0.2, 1.0]) gl.glMaterial(gl.GL_FRONT, gl.GL_DIFFUSE, [0.8, 0.8, 0.8, 1.0]) gl.glMaterial(gl.GL_FRONT, gl.GL_SPECULAR, [1.0, 0.0, 1.0, 1.0]) gl.glMaterial(gl.GL_FRONT, gl.GL_SHININESS, 50.0) gl.glLight(gl.GL_LIGHT0, gl.GL_AMBIENT, [1.0, 1.0, 1.0, 1.0]) gl.glLight(gl.GL_LIGHT0, gl.GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0]) gl.glLight(gl.GL_LIGHT0, gl.GL_SPECULAR, [1.0, 1.0, 1.0, 1.0]) gl.glLight(gl.GL_LIGHT0, gl.GL_POSITION, [1.0, 1.0, 1.0, 0.0]) gl.glLightModelfv(gl.GL_LIGHT_MODEL_AMBIENT, [0.2, 0.2, 0.2, 1.0]) gl.glEnable(gl.GL_LIGHTING) gl.glEnable(gl.GL_LIGHT0) gl.glDepthFunc(gl.GL_LESS) gl.glClearDepth(1.0) # enables clearing of the depth buffer? gl.glShadeModel(gl.GL_SMOOTH) gl.glEnable(gl.GL_DEPTH_TEST) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) # position viewer gl.glMatrixMode(gl.GL_MODELVIEW) # position viewer gl.glTranslate(0.0, 0.0, -3.0); # glut.glutInit(sys.argv)
def setUp(self): glut.glutInit() glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH) glut.glutInitWindowSize(20, 20) self.window_id = glut.glutCreateWindow(self.__class__.__name__) self.test_data_path = os.path.join(testDir, 'test_data')
def main(): 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.glutDisplayFunc(draw) load() GL.glEnable(GL.GL_MULTISAMPLE) GL.glEnable(GL.GL_DEPTH_TEST) GL.glEnable(GL.GL_TEXTURE_2D) GL.glClearColor(*corFundo) GL.glClearDepth(1.0) GL.glDepthFunc(GL.GL_LESS) GL.glShadeModel(GL.GL_SMOOTH) GL.glMatrixMode(GL.GL_PROJECTION) GLU.gluPerspective(-45, larguraJanela / alturaJanela, 0.1, 100.0) GL.glTranslatef(0.0, 0.0, -10) GL.glMatrixMode(GL.GL_MODELVIEW) GLUT.glutTimerFunc(10, timer, 1) GLUT.glutMainLoop()
def initOpenGLMatrix(self): # FROM http://code.activestate.com/recipes/325391-open-a-glut-window-and-draw-a-sphere-using-pythono/ glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_DEPTH) glut.glutInitWindowSize(400, 400) glut.glutCreateWindow(b'PyTowerDefense') gl.glClearColor(0., 0., 0., 1.) gl.glShadeModel(gl.GL_SMOOTH) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_LIGHTING) gl.lightZeroPosition = [100., 40., 100., 1.] gl.lightZeroColor = [0.8, 1.0, 0.8, 1.0] #green tinged gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, gl.lightZeroPosition) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, gl.lightZeroColor) gl.glLightf(gl.GL_LIGHT0, gl.GL_CONSTANT_ATTENUATION, 0.01) gl.glLightf(gl.GL_LIGHT0, gl.GL_LINEAR_ATTENUATION, 0.005) gl.glEnable(gl.GL_LIGHT0) glut.glutDisplayFunc(self.paint) glut.glutIdleFunc(self.repaint) gl.glMatrixMode(gl.GL_PROJECTION) glu.gluPerspective(30., 1., 1., 1000.) gl.glMatrixMode(gl.GL_MODELVIEW) self._eyePosition = Point3D("Camera Eye Location").translate(0, 0, 400) self._watchingPosition = Point3D("Camera Watching Position") self._upVector = Point3D("Camera Up Vector").translate(0, 1, 0) glu.gluLookAt(self._eyePosition.x, self._eyePosition.y, self._eyePosition.z, self._watchingPosition.x, self._watchingPosition.y, self._watchingPosition.z, self._upVector.x, self._upVector.y, self._upVector.z) gl.glPushMatrix() return
def glInit(): OGLUT.glutInit() # initialize the GLUT library. OGLUT.glutInitDisplayMode(OGLUT.GLUT_DOUBLE | OGLUT.GLUT_RGB |OGLUT.GLUT_DEPTH) # initial display mode OGL.glShadeModel(OGL.GL_SMOOTH) # Enable Smooth Shading OGL.glClearColor(0.0, 0.0, 0.0, 0.0) # Black Background OGL.glClearDepth(1.0) # Depth Buffer Setup OGL.glEnable(OGL.GL_DEPTH_TEST) # Enables Depth Testing OGL.glDepthFunc(OGL.GL_LEQUAL) # The Type Of Depth Testing To Do OGL.glHint(OGL.GL_PERSPECTIVE_CORRECTION_HINT, OGL.GL_NICEST) # Really Nice Perspective Calculations objCamera.Position_Camera(10, 4, 12, 9, 4, 12, 0, 1, 0) # Set Camera Position LoadVertices() OGL.glViewport(0,0,SCREEN_SIZE[0],SCREEN_SIZE[1]) # Reset The Current Viewport OGL.glMatrixMode(OGL.GL_PROJECTION) OGL.glLoadIdentity() # Calculate The Aspect Ratio Of The Window OGLU.gluPerspective(45.0, SCREEN_SIZE[0]/SCREEN_SIZE[1], 0.1, 100.0) OGL.glMatrixMode(OGL.GL_MODELVIEW) OGL.glCullFace(OGL.GL_BACK) # Don't draw the back sides of polygons OGL.glEnable(OGL.GL_CULL_FACE) # Turn on culling
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, ): 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(argv): GLUT.glutInit(argv) GLUT.glutCreateWindow(str.encode(sys.argv[0])) interaction_m = InteractionMatrix() interaction_m.add_translation(1, 2, 3) interaction_m.add_rotation(30, 0, 0, 1) interaction_m.add_translation(1, 2, 3)
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, 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 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 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_glut(): # HiDPI support for retina display # This requires glut from # http://iihm.imag.fr/blanch/software/glut-macosx/ if sys.platform == 'darwin': try: glutInitDisplayString = platform.createBaseFunction( 'glutInitDisplayString', dll=platform.GLUT, resultType=None, argTypes=[ctypes.c_char_p], doc='glutInitDisplayString( ) -> None', argNames=()) text = ctypes.c_char_p("rgba stencil double samples=8 hidpi") glutInitDisplayString(text) except Exception: pass glut.glutInit(['vispy'.encode('ASCII')]) # todo: allow user to give args? mode = (glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_STENCIL | glut.GLUT_DEPTH) if bool(glut.glutInitDisplayMode): glut.glutInitDisplayMode(mode) # Prevent exit when closing window try: glut.glutSetOption(glut.GLUT_ACTION_ON_WINDOW_CLOSE, glut.GLUT_ACTION_CONTINUE_EXECUTION) except Exception: pass return glut
def thread_main(instance): # sys.stderr.write("Starting thread_main\n") GLUT.glutInit(sys.argv) GLUT.glutInitContextVersion(3, 3) 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) GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH) # sys.stderr.write("Making default GLUT window.\n") GLUT.glutInitWindowSize(instance.width, instance.height) GLUT.glutInitWindowPosition(0, 0) instance.window = GLUT.glutCreateWindow( bytes(instance._title, encoding='UTF-8')) # Urgh.... according to the docs, I'm MUST register a display function # for any GLUT window I create. But... I don't want to do this until # later (in self.__init__). So, register a null function now, # and hope that registering a new function is an OK thing to do. GLUT.glutDisplayFunc(lambda: None) # Not sure if I want this as a timer or an idle func GLUT.glutIdleFunc(lambda: GLUTContext.class_idle()) # GLUT.glutTimerFunc(10, lambda val : GLUTContext.class_idle(), 0) sys.stderr.write("Going into GLUT.GLUT main loop.\n") GLUTContext._class_init = True GLUT.glutMainLoop()
def setUpModule(): global window if not window: GLUT.glutInit(sys.argv) GLUT.glutInitDisplayMode(GLUT.GLUT_DOUBLE | GLUT.GLUT_RGBA | GLUT.GLUT_DEPTH) GLUT.glutInitWindowSize(1024, 768) window = GLUT.glutCreateWindow("OMGL (GLUT)")
def main(): glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB | glut.GLUT_DEPTH) glut.glutInitWindowSize(400,400) glut.glutCreateWindow("teapot") gl.glClearColor(0.,0.,0.,1.) gl.glShadeModel(gl.GL_SMOOTH) gl.glEnable(gl.GL_CULL_FACE) gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_LIGHTING) lightZeroPosition = [10.,4.,10.,1.] lightZeroColor = [0.8,1.0,0.8,1.0] #green tinged gl.glLightfv(gl.GL_LIGHT0, gl.GL_POSITION, lightZeroPosition) gl.glLightfv(gl.GL_LIGHT0, gl.GL_DIFFUSE, lightZeroColor) gl.glLightf(gl.GL_LIGHT0, gl.GL_CONSTANT_ATTENUATION, 0.1) gl.glLightf(gl.GL_LIGHT0, gl.GL_LINEAR_ATTENUATION, 0.05) gl.glEnable(gl.GL_LIGHT0) glut.glutDisplayFunc(display) gl.glMatrixMode(gl.GL_PROJECTION) glu.gluPerspective(40.,1.,1.,40.) gl.glMatrixMode(gl.GL_MODELVIEW) glu.gluLookAt(0,0,10, 0,0,0, 0,1,0) gl.glPushMatrix() glut.glutMainLoop() return
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 _vispy_get_native_app(self): # HiDPI support for retina display # This requires glut from # http://iihm.imag.fr/blanch/software/glut-macosx/ if sys.platform == 'darwin': try: glutInitDisplayString = platform.createBaseFunction( 'glutInitDisplayString', dll=platform.GLUT, resultType=None, argTypes=[ ctypes.c_char_p], doc='glutInitDisplayString( ) -> None', argNames=()) text = ctypes.c_char_p("rgba stencil double samples=8 hidpi") glutInitDisplayString(text) except: pass if not self._initialized: glut.glutInit() # todo: maybe allow user to give args? glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_DOUBLE | glut.GLUT_STENCIL | glut.GLUT_DEPTH) self._initialized = True return glut
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, parent): """Initialise canvas properties and useful variables.""" super().__init__(parent, -1, attribList=[ wxcanvas.WX_GL_RGBA, wxcanvas.WX_GL_DOUBLEBUFFER, wxcanvas.WX_GL_DEPTH_SIZE, 16, 0 ]) GLUT.glutInit() self.context = wxcanvas.GLContext(self) # keep reference to parent self.parent = parent # set up drawing modes self.draw_2D = MyGLCanvas_2D(self) # default mode self.draw_3D = MyGLCanvas_3D(self) # start in 2D mode self.current_mode = self.draw_2D # Bind events to the canvas self.Bind(wx.EVT_PAINT, self.current_mode.on_paint) self.Bind(wx.EVT_SIZE, self.current_mode.on_size) self.Bind(wx.EVT_MOUSE_EVENTS, self.current_mode.on_mouse)
def render(self, glcanvas): if not self.message == '': glDisable(GL_LIGHTING) glPushMatrix() glLoadIdentity() glOrtho(-1, 1, -1, 1, -1, 1) # def glut_print(x, y, font, text, r, g, b, a): # blending = False # if glIsEnabled(GL_BLEND): # blending = True # glEnable(GL_BLEND) glColor3f(1, 1, 1) glRasterPos2f(self.x, self.y) # on windows we must have a glutInit call # on mac this seems not absolutely vital GLUT.glutInit() for ch in self.message: GLUT.glutBitmapCharacter(GLUT.GLUT_BITMAP_9_BY_15, ctypes.c_int(ord(ch))) # GLUT.glutBitmapString(GLUT.GLUT_BITMAP_9_BY_15, ctypes.c_char_p(self.message)) # if not blending: # glDisable(GL_BLEND) glPopMatrix() glEnable(GL_LIGHTING)
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): """ 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 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, parent, devices, monitors, network): """Initialise canvas properties and useful variables.""" super().__init__(parent.canvas3d_panel, -1, attribList=[ wxcanvas.WX_GL_RGBA, wxcanvas.WX_GL_DOUBLEBUFFER, wxcanvas.WX_GL_DEPTH_SIZE, 16, 0 ]) GLUT.glutInit() self.init = False self.context = wxcanvas.GLContext(self) self.devices = devices self.network = network self.monitors = monitors self.parent = parent # Constants for OpenGL materials and lights self.mat_diffuse = [0.0, 0.0, 0.0, 1.0] self.mat_no_specular = [0.0, 0.0, 0.0, 0.0] self.mat_no_shininess = [0.0] self.mat_specular = [0.5, 0.5, 0.5, 1.0] self.mat_shininess = [50.0] self.top_right = [1.0, 1.0, 1.0, 0.0] self.straight_on = [0.0, 0.0, 1.0, 0.0] self.no_ambient = [0.0, 0.0, 0.0, 1.0] self.dim_diffuse = [0.5, 0.5, 0.5, 1.0] self.bright_diffuse = [1.0, 1.0, 1.0, 1.0] self.med_diffuse = [0.75, 0.75, 0.75, 1.0] self.full_specular = [0.5, 0.5, 0.5, 1.0] self.no_specular = [0.0, 0.0, 0.0, 1.0] # Initialise variables for panning self.pan_x = 0 self.pan_y = 0 self.last_mouse_x = 0 # previous mouse x position self.last_mouse_y = 0 # previous mouse y position # Initialise the scene rotation matrix self.scene_rotate = np.identity(4, 'f') # Initialise variables for zooming self.zoom = 1 self.scale_x = 50 self.scale_y = 50 self.scale_z = 30 self.signals = [] self.max_x = 0 self.size = self.GetClientSize() # Offset between viewpoint and origin of the scene self.depth_offset = 800 # Bind events to the canvas self.Bind(wx.EVT_PAINT, self.on_paint) self.Bind(wx.EVT_SIZE, self.on_size) self.Bind(wx.EVT_MOUSE_EVENTS, self.on_mouse)
def __init__(self, name, width, height): self.name = name self.width = width self.height = height # Setup window: GLUT.glutInit() GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA | GLUT.GLUT_DOUBLE | GLUT.GLUT_DEPTH) GLUT.glutInitWindowSize(self.width, self.height)
def prepareGLUT(self): glut.glutInit(sys.argv) glut.glutInitWindowSize(self.width, self.height) glut.glutCreateWindow('Sample Shader Heatmap') glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB) # glut.glutInitDisplayMode(glut.GLUT_RGB) glut.glutDisplayFunc(self.display) glut.glutKeyboardFunc(self.keyPressed)
def InitPyGame(): GLUT.glutInit(()) pygame.init() if config.full_screen: s = pygame.display.set_mode((1024, 768), locals.DOUBLEBUF | locals.OPENGL | locals.FULLSCREEN) else: s = pygame.display.set_mode((1024, 768), locals.DOUBLEBUF | locals.OPENGL) return s
def window(w=800,h=800,title='light',px=100,py=100): #glut init glut.glutInit(sys.argv) glut.glutInitDisplayMode (glut.GLUT_DOUBLE | glut.GLUT_RGB) glut.glutInitWindowSize (w, h) glut.glutInitWindowPosition (px, py) glut.glutCreateWindow (title)
def window(w=800, h=800, title='light', px=100, py=100): #glut init glut.glutInit(sys.argv) glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGB) glut.glutInitWindowSize(w, h) glut.glutInitWindowPosition(px, py) glut.glutCreateWindow(title)
def setUp(self): self.window_size = (400, 400) GLUT.glutInit() GLUT.glutInitContextVersion(3, 3) GLUT.glutInitContextProfile(GLUT.GLUT_CORE_PROFILE) GLUT.glutInitDisplayMode(GLUT.GLUT_RGBA) GLUT.glutInitWindowSize(*self.window_size) self.window = GLUT.glutCreateWindow("GLPy Test")
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 window(self): glut.glutInit(sys.argv) glut.glutInitDisplayMode (self.disp_mode) w,h=self.win_size glut.glutInitWindowSize (w,h) px,py=self.win_pos glut.glutInitWindowPosition (px,py) glut.glutCreateWindow (self.win_title)
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 mainfunc(self): glut.glutInit() glut.glutInitDisplayMode(glut.GLUT_RGBA | glut.GLUT_3_2_CORE_PROFILE) glut.glutInitWindowSize(512, 512) #glut.glutInitContextVersion(4, 3) #glut.glutInitContextProfile(glut.GLUT_CORE_PROFILE) glut.glutCreateWindow('CH01_01') self.init() glut.glutDisplayFunc(self.disp) glut.glutMainLoop()
def initglut(): global GLUTINITED if not GLUTINITED and sys.platform.startswith(('linux', 'win')): from OpenGL import GLUT try: GLUT.glutInit([]) ## in order to call Y.glutText() except OpenGL.error.NullFunctionError: #pass raise RuntimeError('FreeGlut is not installed on your computer') #print('FreeGlut is not installed on your computer') GLUTINITED = True
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()