def get_gl_sharing_context_properties(): ctx_props = cl.context_properties from OpenGL import platform as gl_platform props = [] import sys if sys.platform in ["linux", "linux2"]: from OpenGL import GLX props.append( (ctx_props.GL_CONTEXT_KHR, GLX.glXGetCurrentContext())) props.append( (ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": from OpenGL import WGL props.append( (ctx_props.GL_CONTEXT_KHR, gl_platform.GetCurrentContext())) props.append( (ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) elif sys.platform == "darwin": props.append( (ctx_props.CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, cl.get_apple_cgl_share_group())) else: raise NotImplementedError("platform '%s' not yet supported" % sys.platform) return props
def __exit__(self, *_args): self.valid = False if self.context: context_type = type(self.context) null_context = cast(0, context_type) log("glXMakeCurrent: NULL for xid=%#x", self.xid) GLX.glXMakeCurrent(self.xdisplay, 0, null_context)
def get_gl_sharing_context_properties(): import pyopencl as cl ctx_props = cl.context_properties from OpenGL import platform as gl_platform props = [] import sys if sys.platform in ["linux", "linux2"]: from OpenGL import GLX props.append((ctx_props.GL_CONTEXT_KHR, GLX.glXGetCurrentContext())) props.append((ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": from OpenGL import WGL props.append( (ctx_props.GL_CONTEXT_KHR, gl_platform.GetCurrentContext())) props.append((ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) elif sys.platform == "darwin": props.append((ctx_props.CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, cl.get_apple_cgl_share_group())) else: raise NotImplementedError("platform '%s' not yet supported" % sys.platform) return props
def __init__(self, wid): """Constructor for OpenGLRenderingArea""" xlib = cdll.LoadLibrary('libX11.so') xlib.XOpenDisplay.argtypes = [c_char_p] xlib.XOpenDisplay.restype = POINTER(struct__XDisplay) self.xdisplay = xlib.XOpenDisplay((ctypes.c_char * 1)(*[0])) display = Display() attrs = [ GLX.GLX_RGBA, True, GLX.GLX_RED_SIZE, 1, GLX.GLX_GREEN_SIZE, 1, GLX.GLX_BLUE_SIZE, 1, GLX.GLX_DOUBLEBUFFER, 0, 0, 0 ] width = 200 height = 200 cattrs = (c_int * len(attrs))(*attrs) xvinfo = GLX.glXChooseVisual(self.xdisplay, display.get_default_screen(), cattrs) configs = GLX.glXChooseFBConfig(self.xdisplay, 0, None, byref(c_int())) self.context = GLX.glXCreateContext(self.xdisplay, xvinfo, None, True) self.x_window_id = GdkX11.X11Window.get_xid(wid) if not GLX.glXMakeCurrent(self.xdisplay, self.x_window_id, self.context): print("failed") GL.glViewport(0, 0, width, height) # todo self.app = None GL.glClearColor(0.24, 0.24, 0.24, 0.0) self.profiler_window = None
def initialize(): plats = cl.get_platforms() ctx_props = cl.context_properties props = [(ctx_props.PLATFORM, plats[0]), (ctx_props.GL_CONTEXT_KHR, platform.GetCurrentContext())] import sys if sys.platform == "linux2": props.append( (ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": props.append( (ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) ctx = cl.Context(properties=props) glClearColor(1, 1, 1, 1) glColor(0, 0, 1) vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, vbo) rawGlBufferData(GL_ARRAY_BUFFER, n_vertices * 2 * 4, None, GL_STATIC_DRAW) glEnableClientState(GL_VERTEX_ARRAY) glVertexPointer(2, GL_FLOAT, 0, None) coords_dev = cl.GLBuffer(ctx, cl.mem_flags.READ_WRITE, int(vbo)) prog = cl.Program(ctx, src).build() queue = cl.CommandQueue(ctx) cl.enqueue_acquire_gl_objects(queue, [coords_dev]) prog.generate_sin(queue, (n_vertices,), None, coords_dev) cl.enqueue_release_gl_objects(queue, [coords_dev]) queue.finish() glFlush()
def __init__(self): plats = cl.get_platforms() ctx_props = cl.context_properties self.props = [(ctx_props.PLATFORM, plats[0]), (ctx_props.GL_CONTEXT_KHR, platform.GetCurrentContext())] if sys.platform == "linux2": self.props.append((ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": self.props.append((ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) self.ctx = cl.Context(properties=self.props) self.cross4 = ElementwiseKernel( self.ctx, "__global const float4 *u, " "__global const float4 *v, " "__global const float4 *w, " "__global float4 *r", "r[i] = cross4(u[i],v[i],w[i])", "cross4_final", preamble=cross4_preamble) self.distance2 = ElementwiseKernel( self.ctx, "__global const float4 *a, " "__global const float4 *b, " "__global float4 *d", "d[i] = distance2(a[i],b[i])", "distance_final", preamble=distance_preamble) self.place_hyperspheres()
def initialize(): plats = cl.get_platforms() ctx_props = cl.context_properties props = [(ctx_props.PLATFORM, plats[0]), (ctx_props.GL_CONTEXT_KHR, platform.GetCurrentContext())] import sys if sys.platform == "linux2": props.append((ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": props.append((ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) ctx = cl.Context(properties=props) glClearColor(1, 1, 1, 1) glColor(0, 0, 1) vbo = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, vbo) rawGlBufferData(GL_ARRAY_BUFFER, n_vertices * 2 * 4, None, GL_STATIC_DRAW) glEnableClientState(GL_VERTEX_ARRAY) glVertexPointer(2, GL_FLOAT, 0, None) coords_dev = cl.GLBuffer(ctx, cl.mem_flags.READ_WRITE, int(vbo)) prog = cl.Program(ctx, src).build() queue = cl.CommandQueue(ctx) cl.enqueue_acquire_gl_objects(queue, [coords_dev]) prog.generate_sin(queue, (n_vertices, ), None, coords_dev) cl.enqueue_release_gl_objects(queue, [coords_dev]) queue.finish() glFlush()
def reshape(self, widget, event): self.width = event.width self.height = event.height self.xwindow_id = GdkX11.X11Window.get_xid(widget.get_window()) if(not GLX.glXMakeCurrent(self.xdisplay, self.xwindow_id, self.context)): print('failed binding opengl context') glViewport(0, 0, self.width, self.height)
def set_size(self, width, height): """Change size of rendering area :param height: :param width: """ if not GLX.glXMakeCurrent(self.xdisplay, self.x_window_id, self.context): print("failed") GL.glViewport(0, 0, width, height) # todo
def __exit__(self, *_args): self.valid = False if self.context: context_type = type(self.context) null_context = cast(0, context_type) log("glXMakeCurrent: NULL for xid=%#x", self.xid) if not GLX.glXMakeCurrent(self.xdisplay, 0, null_context): log.error("Error: glXMakeCurrent NULL failed")
def activate(self): """make cairo context current for drawing""" if(not GLX.glXMakeCurrent(self.xdisplay, self.xwindow_id, self.context)): print("failed binding opengl context") #glcontext = gtk.gtkgl.widget_get_gl_context(self) #gldrawable = gtk.gtkgl.widget_get_gl_drawable(self) #return gldrawable and glcontext and gldrawable.gl_begin(glcontext) return True
def _async_init(self): # Create an SDL2 window sdl2.ext.init() if sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO) != 0: raise RuntimeError(sdl2.SDL_GetError()) self._window = sdl2.SDL_CreateWindow( self._window_title.encode(), sdl2.SDL_WINDOWPOS_UNDEFINED, sdl2.SDL_WINDOWPOS_UNDEFINED, self.width, self.height, sdl2.SDL_WINDOW_OPENGL | sdl2.SDL_WINDOW_RESIZABLE | sdl2.SDL_WINDOW_UTILITY, ) # Create an OpenGL context sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MAJOR_VERSION, self.OPENGL_VERSION[0]) sdl2.video.SDL_GL_SetAttribute(sdl2.video.SDL_GL_CONTEXT_MINOR_VERSION, self.OPENGL_VERSION[1]) sdl2.video.SDL_GL_SetAttribute( sdl2.video.SDL_GL_CONTEXT_PROFILE_MASK, sdl2.video.SDL_GL_CONTEXT_PROFILE_CORE, ) self._glcontext = sdl2.SDL_GL_CreateContext(self._window) sdl2.SDL_GL_MakeCurrent(self._window, self._glcontext) # Activate vertical synchronization sdl2.SDL_GL_SetSwapInterval(1) # Set the GLX context GLX.glXMakeCurrent(self.x11display, self.x11window, self.glx_context) # Call subclass custom initialization self.init(**self._init_kwds) # Start rendering sdl2.SDL_ShowWindow(self._window) self._timer = self._loop.create_timer(self._on_update) self._loop.set_timer(self._timer, 1, int(1000.0 / 60.0))
def render(self): """Must be called each frame""" if not GLX.glXMakeCurrent(self.xdisplay, self.x_window_id, self.context): print("failed") GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) #todo GL.glBegin(GL.GL_TRIANGLES) GL.glIndexi(0) GL.glColor3f(1.0, 0.0, 0.0) GL.glVertex2i(0, 1) GL.glIndexi(0) GL.glColor3f(0.0, 1.0, 0.0) GL.glVertex2i(-1, -1) GL.glIndexi(0) GL.glColor3f(0.0, 0.0, 1.0) GL.glVertex2i(1, -1) GL.glEnd() self.app.render_loop() GLX.glXSwapBuffers(self.xdisplay, self.x_window_id) self.profiler_window.one_frame_passed() return True
def get_context_properties(self, plat): #reference context properties enumeration out = [] #link OpenCL context platform out.append((context_properties.PLATFORM, plat)) #link OpenGL context out.append((context_properties.GL_CONTEXT_KHR, platform.GetCurrentContext())) #link platform specific window contexts if "GLX" in globals(): out.append((context_properties.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) if "WGL" in globals(): out.append((context_properties.WGL_HDC_KHR, WGL.wglGetCurrentDC())) #return context properties return out
def clinit(self): plats = cl.get_platforms() ctx_props = cl.context_properties props = [(ctx_props.PLATFORM, plats[0]), (ctx_props.GL_CONTEXT_KHR, platform.GetCurrentContext())] import sys if sys.platform == "linux2": props.append( (ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": props.append((ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) self.ctx = cl.Context(properties=props) self.queue = cl.CommandQueue(self.ctx)
def clinit(self): plats = cl.get_platforms() ctx_props = cl.context_properties props = [(ctx_props.PLATFORM, plats[0]), (ctx_props.GL_CONTEXT_KHR, platform.GetCurrentContext())] import sys if sys.platform == "linux2": props.append((ctx_props.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) elif sys.platform == "win32": props.append((ctx_props.WGL_HDC_KHR, WGL.wglGetCurrentDC())) self.ctx = cl.Context(properties=props) self.queue = cl.CommandQueue(self.ctx)
def get_context_properties(self, plat): #reference context properties enumeration out = [] #link OpenCL context platform out.append((context_properties.PLATFORM, plat)) #link OpenGL context out.append( (context_properties.GL_CONTEXT_KHR, platform.GetCurrentContext())) #link platform specific window contexts if "GLX" in globals(): out.append((context_properties.GLX_DISPLAY_KHR, GLX.glXGetCurrentDisplay())) if "WGL" in globals(): out.append((context_properties.WGL_HDC_KHR, WGL.wglGetCurrentDC())) #return context properties return out
def __enter__(self): if not GLX.glXMakeCurrent(self.xdisplay, self.xid, self.context): raise Exception("glXMakeCurrent failed") self.valid = True
from OpenGL.GLUT import * from OpenGL.GLU import * from OpenGL.GL import * from OpenGL import platform as gl_platform from OpenGL import GLX from pycl import * import numpy as np glutInit() gl_window = glutCreateWindow("window") gl_ctx = gl_platform.GetCurrentContext() glx_display = GLX.glXGetCurrentDisplay() cl_ctx_props = { CL_GL_CONTEXT_KHR: gl_ctx, CL_GLX_DISPLAY_KHR: glx_display, } cl_ctx = clCreateContext(other_props=cl_ctx_props) cl_queue = clCreateCommandQueue(cl_ctx) def idle(): input_data = np.arange(20, dtype=np.float32) gl_buf = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, gl_buf) glBufferData(GL_ARRAY_BUFFER, input_data, GL_STATIC_DRAW) glFinish() cl_buf = clCreateFromGLBuffer(cl_ctx, gl_buf) clEnqueueAcquireGLObjects(cl_queue, [cl_buf])
def tkSwapBuffers(self): if self.winfo_ismapped(): GLX.glXSwapBuffers(self.__window, self._wid)
def tkMakeCurrent(self): if self.winfo_ismapped(): GLX.glXMakeCurrent(self.__window, self._wid, self.__context)
def tkCreateContext(self): self.__window = XOpenDisplay(self.winfo_screen().encode('utf-8')) # Check glx version: major = c_int(0) minor = c_int(0) GLX.glXQueryVersion(self.__window, major, minor) print("GLX version: %d.%d" % (major.value, minor.value)) if major.value == 1 and minor.value < 3: # e.g. 1.2 and down visual = GLX.glXChooseVisual(self.__window, 0, (GL.GLint * len(att))(*att)) if not visual: _log.error("glXChooseVisual call failed") self.__context = GLX.glXCreateContext(self.__window, visual, None, GL.GL_TRUE) GLX.glXMakeCurrent(self.__window, self._wid, self.__context) return # OUT HERE FOR 1.2 and less else: # 1.3 or higher # which screen - should it be winfo_screen instead ?? XDefaultScreen = _x11lib.XDefaultScreen XDefaultScreen.argtypes = [POINTER(Display)] XDefaultScreen.restype = c_int screen = XDefaultScreen(self.__window) print("Screen is ", screen) # Look at framebuffer configs ncfg = GL.GLint(0) cfgs = GLX.glXChooseFBConfig(self.__window, screen, (GL.GLint * len(fbatt))(*fbatt), ncfg) print("Number of FBconfigs", ncfg.value) # # Try to match to the current window # ... might also be possible to set this for the frame # ... but for now we just take what Tk gave us ideal = int(self.winfo_visualid(), 16) # convert from hex best = -1 for i in range(ncfg.value): vis = GLX.glXGetVisualFromFBConfig(self.__window, cfgs[i]) if ideal == vis.contents.visualid: best = i print("Got a matching visual: index %d %d xid %s" % (best, vis.contents.visualid, hex(ideal))) if best < 0: print("oh dear - visual does not match") # Take the first in the list (should be another I guess) best = 0 # Here we insist on RGBA - but didn't check earlier self.__context = GLX.glXCreateNewContext( self.__window, cfgs[best], GLX.GLX_RGBA_TYPE, None, # share list GL.GL_TRUE) # direct print("Is Direct?: ", GLX.glXIsDirect(self.__window, self.__context)) # Not creating another window ... some tutorials do # print("wid: ",self._wid) # self._wid = GLX.glXCreateWindow( self.__window, cfgs[best], self._wid, None) # print("wid: ",self._wid) GLX.glXMakeContextCurrent(self.__window, self._wid, self._wid, self.__context) print("Done making a first context") extensions = GLX.glXQueryExtensionsString( self.__window, screen) # Here we quit - getting a modern context needs further work below return if "GLX_ARB_create_context" in extensions: # We can try to upgrade it ?? print("Trying to upgrade context") s = "glXCreateContextAttribsARB" p = GLX.glXGetProcAddress(c_char_p(s)) print(p) if not p: p = GLX.glXGetProcAddressARB( (GL.GLubyte * len(s)).from_buffer_copy(s)) print(p) if p: print(" p is true") p.restype = GLX.GLXContext p.argtypes = [ POINTER(Display), GLX.GLXFBConfig, GLX.GLXContext, c_bool, POINTER(c_int) ] arb_attrs = fbatt[:-1] + [] # GLX.GLX_CONTEXT_MAJOR_VERSION_ARB , 3 # GLX.GLX_CONTEXT_MINOR_VERSION_ARB , 1, # 0 ] # # GLX.GLX_CONTEXT_FLAGS_ARB # GLX.GLX_CONTEXT_PROFILE_MASK_ARB #] # import pdb # pdb.set_trace() self.__context = p(self.__window, cfgs[best], None, GL.GL_TRUE, (GL.GLint * len(arb_attrs))(*arb_attrs))
def __init__(self, inifile): self.xwindow_id = None #self.set_has_alpha(True) #'set_has_stencil_buffer', glutInit() glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH ) self.add_attribute(GLX.GLX_RGBA, True) self.add_attribute(GLX.GLX_RED_SIZE, 1) self.add_attribute(GLX.GLX_GREEN_SIZE, 1) self.add_attribute(GLX.GLX_BLUE_SIZE, 1) self.add_attribute(GLX.GLX_DOUBLEBUFFER, 1) xvinfo = GLX.glXChooseVisual(self.xdisplay, self.display.get_default_screen(), self.get_attributes()) configs = GLX.glXChooseFBConfig(self.xdisplay, 0, None, byref(c_int())) self.context = GLX.glXCreateContext(self.xdisplay, xvinfo, None, True) #class Gremlin(gtk.gtkgl.widget.DrawingArea, glnav.GlNavBase, # rs274.glcanon.GlCanonDraw): # rotation_vectors = [(1.,0.,0.), (0., 0., 1.)] # def __init__(self, inifile): # # display_mode = ( gtk.gdkgl.MODE_RGB | gtk.gdkgl.MODE_DEPTH | # gtk.gdkgl.MODE_DOUBLE ) # glconfig = gtk.gdkgl.Config(mode=display_mode) # gtk.gtkgl.widget.DrawingArea.__init__(self, glconfig) glnav.GlNavBase.__init__(self) def C(s): a = self.colors[s + "_alpha"] s = self.colors[s] return [int(x * 255) for x in s + (a,)] self.inifile = inifile self.logger = linuxcnc.positionlogger(linuxcnc.stat(), C('backplotjog'), C('backplottraverse'), C('backplotfeed'), C('backplotarc'), C('backplottoolchange'), C('backplotprobing'), self.get_geometry() ) _thread.start_new_thread(self.logger.start, (.01,)) rs274.glcanon.GlCanonDraw.__init__(self, linuxcnc.stat(), self.logger) self.current_view = 'z' self.select_primed = None self.connect_after('realize', self.realize) self.connect('configure_event', self.reshape) self.connect('map_event', self.map) self.connect('draw', self.expose) # expose_event was deprecated self.connect('motion-notify-event', self.motion) self.connect('button-press-event', self.pressed) self.connect('button-release-event', self.select_fire) self.connect('scroll-event', self.scroll) self.add_events(Gdk.EventMask.POINTER_MOTION_MASK) self.add_events(Gdk.EventMask.POINTER_MOTION_HINT_MASK) #self.add_events(gdk.BUTTON_MOTION_MASK) #self.add_events(gdk.EventMask.BUTTON_PRESS_MASK) #self.add_events(gdk.BUTTON_RELEASE_MASK) self.add_events(Gdk.EventMask.BUTTON_MOTION_MASK) self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK) self.add_events(Gdk.EventMask.BUTTON_RELEASE_MASK) self.add_events(Gdk.EventMask.SCROLL_MASK) self.fingerprint = () self.lat = 0 self.minlat = -90 self.maxlat = 90 self.highlight_line = None self.program_alpha = False self.use_joints_mode = False self.use_commanded = True self.show_limits = True self.show_extents_option = True self.show_live_plot = True self.show_velocity = True self.metric_units = True self.show_program = True self.show_rapids = True self.use_relative = True self.show_tool = True self.show_dtg = True self.grid_size = 0.0 temp = inifile.find("DISPLAY", "LATHE") self.lathe_option = bool(temp == "1" or temp == "True" or temp == "true" ) self.foam_option = bool(inifile.find("DISPLAY", "FOAM")) self.show_offsets = False self.use_default_controls = True self.mouse_btn_mode = 0 self.a_axis_wrapped = inifile.find("AXIS_A", "WRAPPED_ROTARY") self.b_axis_wrapped = inifile.find("AXIS_B", "WRAPPED_ROTARY") self.c_axis_wrapped = inifile.find("AXIS_C", "WRAPPED_ROTARY") live_axis_count = 0 for i,j in enumerate("XYZABCUVW"): if self.stat.axis_mask & (1<<i) == 0: continue live_axis_count += 1 self.num_joints = int(inifile.find("KINS", "JOINTS") or live_axis_count) glDrawBuffer(GL_BACK) glDisable(GL_CULL_FACE) glLineStipple(2, 0x5555) glDisable(GL_LIGHTING) glClearColor(0,0,0,0) glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
from OpenGL.GLUT import * from OpenGL.GLU import * from OpenGL.GL import * from OpenGL import platform as gl_platform from OpenGL import GLX from pycl import * import numpy as np glutInit() gl_window = glutCreateWindow("window") gl_ctx = gl_platform.GetCurrentContext() glx_display = GLX.glXGetCurrentDisplay() cl_ctx_props = { CL_GL_CONTEXT_KHR: gl_ctx, CL_GLX_DISPLAY_KHR: glx_display, } cl_ctx = clCreateContext(other_props=cl_ctx_props) cl_queue = clCreateCommandQueue(cl_ctx) def idle(): input_data = np.arange(20, dtype=np.float32) gl_buf = glGenBuffers(1) glBindBuffer(GL_ARRAY_BUFFER, gl_buf) glBufferData(GL_ARRAY_BUFFER, input_data, GL_STATIC_DRAW) glFinish() cl_buf = clCreateFromGLBuffer(cl_ctx, gl_buf)
def __exit__(self, *_args): self.valid = False if self.context: context_type = type(self.context) null_context = cast(0, context_type) GLX.glXMakeCurrent(self.xdisplay, 0, null_context)
def __enter__(self): log("glXMakeCurrent: xid=%#x, context=%s", self.xid, self.context) with xsync: if not GLX.glXMakeCurrent(self.xdisplay, self.xid, self.context): raise Exception("glXMakeCurrent failed") self.valid = True
def destroy(self): c = self.context if c: self.context = None GLX.glXDestroyContext(self.xdisplay, c)
def getconfig(attrib): value = c_int() r = GLX.glXGetConfig(self.xdisplay, xvinfo, attrib, byref(value)) assert r == 0, "glXGetConfig returned %i" % r return value.value
def get_process_address(name): address = GLX.glXGetProcAddress(name.decode("utf-8")) return ctypes.cast(address, ctypes.c_void_p).value
def __init__(self, alpha=False): display = display_get_default() screen = display.get_default_screen() bpc = 8 attrs = c_attrs({ GLX.GLX_RGBA: True, GLX.GLX_RED_SIZE: bpc, GLX.GLX_GREEN_SIZE: bpc, GLX.GLX_BLUE_SIZE: bpc, GLX.GLX_ALPHA_SIZE: int(alpha) * bpc, GLX.GLX_DOUBLEBUFFER: int(DOUBLE_BUFFERED), }) self.props = {} self.xdisplay = get_xdisplay() xvinfo = GLX.glXChooseVisual(self.xdisplay, screen.get_number(), attrs) def getconfig(attrib): value = c_int() r = GLX.glXGetConfig(self.xdisplay, xvinfo, attrib, byref(value)) assert r == 0, "glXGetConfig returned %i" % r return value.value assert getconfig( GLX.GLX_USE_GL), "OpenGL is not supported by this visual!" major = c_int() minor = c_int() assert GLX.glXQueryVersion(self.xdisplay, byref(major), byref(minor)) log("found GLX version %i.%i", major.value, minor.value) self.props["GLX"] = (major.value, minor.value) self.bit_depth = getconfig(GLX.GLX_RED_SIZE) + getconfig( GLX.GLX_GREEN_SIZE) + getconfig(GLX.GLX_BLUE_SIZE) + getconfig( GLX.GLX_ALPHA_SIZE) self.props["depth"] = self.bit_depth self.props["has-depth-buffer"] = getconfig(GLX.GLX_DEPTH_SIZE) > 0 self.props["has-stencil-buffer"] = getconfig(GLX.GLX_STENCIL_SIZE) > 0 self.props["has-alpha"] = getconfig(GLX.GLX_ALPHA_SIZE) > 0 for attrib, name in { GLX.GLX_ACCUM_RED_SIZE: "accum-red-size", GLX.GLX_ACCUM_GREEN_SIZE: "accum-green-size", GLX.GLX_ACCUM_BLUE_SIZE: "accum-blue-size", GLX.GLX_ACCUM_ALPHA_SIZE: "accum-alpha-size", GLX.GLX_RED_SIZE: "red-size", GLX.GLX_GREEN_SIZE: "green-size", GLX.GLX_BLUE_SIZE: "blue-size", GLX.GLX_ALPHA_SIZE: "alpha-size", GLX.GLX_DEPTH_SIZE: "depth-size", GLX.GLX_STENCIL_SIZE: "stencil-size", GLX.GLX_BUFFER_SIZE: "buffer-size", GLX.GLX_AUX_BUFFERS: "aux-buffers", GLX.GLX_DOUBLEBUFFER: "double-buffered", GLX.GLX_LEVEL: "level", GLX.GLX_STEREO: "stereo", GLX.GLX_RGBA: "rgba", }.items(): v = getconfig(attrib) if name in ("stereo", "double-buffered", "rgba"): v = bool(v) self.props[name] = v #attribute names matching gtkgl: display_mode = [] if getconfig(GLX.GLX_RGBA): #this particular context may not have alpha channel support... #but if we have RGBA then it's almost guaranteed that we can do ALPHA display_mode.append("ALPHA") if getconfig(GLX.GLX_DOUBLEBUFFER): display_mode.append("DOUBLE") else: display_mode.append("SINGLE") self.props["display_mode"] = display_mode self.context = GLX.glXCreateContext(self.xdisplay, xvinfo, None, True) self.props["direct"] = bool( GLX.glXIsDirect(self.xdisplay, self.context)) self.props["vendor"] = glGetString(GL_VENDOR) self.props["renderer"] = glGetString(GL_RENDERER) log("GLXContext(%s) context=%s, props=%s", alpha, self.context, self.props)
def __init__(self, alpha=False): display = display_get_default() screen = display.get_default_screen() bpc = 8 attrs = c_attrs({ GLX.GLX_RGBA: True, GLX.GLX_RED_SIZE: bpc, GLX.GLX_GREEN_SIZE: bpc, GLX.GLX_BLUE_SIZE: bpc, GLX.GLX_ALPHA_SIZE: int(alpha) * bpc, GLX.GLX_DOUBLEBUFFER: int(DOUBLE_BUFFERED), }) self.props = {} self.xdisplay = get_xdisplay() xvinfo = GLX.glXChooseVisual(self.xdisplay, screen.get_number(), attrs) def getconfig(attrib): value = c_int() r = GLX.glXGetConfig(self.xdisplay, xvinfo, attrib, byref(value)) assert r == 0, "glXGetConfig returned %i" % r return value.value assert getconfig( GLX.GLX_USE_GL), "OpenGL is not supported by this visual!" major = c_int() minor = c_int() assert GLX.glXQueryVersion(self.xdisplay, byref(major), byref(minor)) log("found GLX version %i.%i", major.value, minor.value) self.props["GLX"] = (major.value, minor.value) self.bit_depth = sum( getconfig(x) for x in (GLX.GLX_RED_SIZE, GLX.GLX_GREEN_SIZE, GLX.GLX_BLUE_SIZE, GLX.GLX_ALPHA_SIZE)) self.props["depth"] = self.bit_depth self.props["has-depth-buffer"] = getconfig(GLX.GLX_DEPTH_SIZE) > 0 self.props["has-stencil-buffer"] = getconfig(GLX.GLX_STENCIL_SIZE) > 0 self.props["has-alpha"] = getconfig(GLX.GLX_ALPHA_SIZE) > 0 for attrib, name in GLX_ATTRIBUTES.items(): v = getconfig(attrib) if name in ("stereo", "double-buffered", "rgba"): v = bool(v) self.props[name] = v #attribute names matching gtkgl: display_mode = [] if getconfig(GLX.GLX_RGBA): #this particular context may not have alpha channel support... #but if we have RGBA then it's almost guaranteed that we can do ALPHA display_mode.append("ALPHA") if getconfig(GLX.GLX_DOUBLEBUFFER): display_mode.append("DOUBLE") else: display_mode.append("SINGLE") self.props["display_mode"] = display_mode self.context = GLX.glXCreateContext(self.xdisplay, xvinfo, None, True) self.props["direct"] = bool( GLX.glXIsDirect(self.xdisplay, self.context)) def getstr(k): try: return glGetString(k) except Exception as e: self.props["safe"] = False result = getattr(e, "result", None) if result and isinstance(result, str): return result raise self.props["vendor"] = getstr(GL_VENDOR) self.props["renderer"] = getstr(GL_RENDERER) log("GLXContext(%s) context=%s, props=%s", alpha, self.context, self.props)
def swap_buffers(self): assert self.valid, "GLX window context is no longer valid" GLX.glXSwapBuffers(self.xdisplay, self.xid)
def __init__(self, alpha=False): self.props = {} self.xdisplay = None self.context = None self.bit_depth = 0 from gi.repository import Gdk display = Gdk.Display.get_default() if not display: log.warn("Warning: GLXContext: no default display") return screen = display.get_default_screen() bpc = 8 pyattrs = { GLX.GLX_RGBA: None, GLX.GLX_RED_SIZE: bpc, GLX.GLX_GREEN_SIZE: bpc, GLX.GLX_BLUE_SIZE: bpc, } if alpha: pyattrs[GLX.GLX_ALPHA_SIZE] = int(alpha) * bpc if DOUBLE_BUFFERED: pyattrs[GLX.GLX_DOUBLEBUFFER] = None attrs = c_attrs(pyattrs) self.xdisplay = get_xdisplay() xvinfo = GLX.glXChooseVisual(self.xdisplay, screen.get_number(), attrs) def getconfig(attrib): value = c_int() r = GLX.glXGetConfig(self.xdisplay, xvinfo, attrib, byref(value)) assert r == 0, "glXGetConfig returned %i" % r return value.value assert getconfig( GLX.GLX_USE_GL), "OpenGL is not supported by this visual!" major = c_int() minor = c_int() assert GLX.glXQueryVersion(self.xdisplay, byref(major), byref(minor)) log("found GLX version %i.%i", major.value, minor.value) self.props["GLX"] = (major.value, minor.value) self.bit_depth = sum( getconfig(x) for x in (GLX.GLX_RED_SIZE, GLX.GLX_GREEN_SIZE, GLX.GLX_BLUE_SIZE, GLX.GLX_ALPHA_SIZE)) self.props["depth"] = self.bit_depth #hide those because we don't use them #and because they're misleading: 'has-alpha' may be False #even when we have RGBA support (and therefore very likely to have alpha..) #self.props["has-depth-buffer"] = getconfig(GLX.GLX_DEPTH_SIZE)>0 #self.props["has-stencil-buffer"] = getconfig(GLX.GLX_STENCIL_SIZE)>0 #self.props["has-alpha"] = getconfig(GLX.GLX_ALPHA_SIZE)>0 for attrib, name in GLX_ATTRIBUTES.items(): v = getconfig(attrib) if name in ("stereo", "double-buffered", "rgba"): v = bool(v) self.props[name] = v #attribute names matching gtkgl: display_mode = [] if getconfig(GLX.GLX_RGBA): #this particular context may not have alpha channel support... #but if we have RGBA then it's almost guaranteed that we can do ALPHA display_mode.append("ALPHA") if getconfig(GLX.GLX_DOUBLEBUFFER): display_mode.append("DOUBLE") else: # pragma: no cover display_mode.append("SINGLE") self.props["display_mode"] = display_mode self.context = GLX.glXCreateContext(self.xdisplay, xvinfo, None, True) self.props["direct"] = bool( GLX.glXIsDirect(self.xdisplay, self.context)) def getstr(k): try: return glGetString(k) except Exception as e: # pragma: no cover self.props["safe"] = False result = getattr(e, "result", None) if result and isinstance(result, str): return result raise self.props["vendor"] = getstr(GL_VENDOR) self.props["renderer"] = getstr(GL_RENDERER) log("GLXContext(%s) context=%s, props=%s", alpha, self.context, self.props)
def swap_buffers(self): assert self.valid GLX.glXSwapBuffers(self.xdisplay, self.xid)
def swapbuffers(self): GLX.glXSwapBuffers(self.xdisplay, self.xwindow_id) #gldrawable = gtk.gtkgl.widget_get_gl_drawable(self) #gldrawable.swap_buffers() return