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, 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):
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 __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)
