class DarwinPlatform(baseplatform.BasePlatform):
"""Darwin (OSX) platform implementation"""
DEFAULT_FUNCTION_TYPE = staticmethod(ctypes.CFUNCTYPE)
EXTENSIONS_USE_BASE_FUNCTIONS = True
# Get the pointers to the libraries...
try:
OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'OpenGL',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
raise ImportError("Unable to load OpenGL library", *err.args)
# CGL provides the windowing environment functionality
# but it is built into the GL libs.
GL = GLU = CGL = OpenGL
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
GLUT = ctypesloader.loadLibrary(ctypes.cdll,
'GLUT',
mode=ctypes.RTLD_GLOBAL)
# GLE is handled by GLUT under OS X
GLE = GLUT
GetCurrentContext = CurrentContextIsValid = staticmethod(
CGL.CGLGetCurrentContext)
def getGLUTFontPointer(self, constant):
"""Platform specific function to retrieve a GLUT font pointer
GLUTAPI void *glutBitmap9By15;
#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15)
Key here is that we want the addressof the pointer in the DLL,
not the pointer in the DLL. That is, our pointer is to the
pointer defined in the DLL, we don't want the *value* stored in
that pointer.
"""
name = [x.title() for x in constant.split('_')[1:]]
internal = 'glut' + "".join([x.title() for x in name])
pointer = ctypes.c_void_p.in_dll(self.GLUT, internal)
return ctypes.c_void_p(ctypes.addressof(pointer))
def safeGetError(self):
"""Provide context-not-present-safe error-checking
Under OS-X an attempt to retrieve error without checking
context will bus-error. This function checks for a valid
context before running glGetError
Note:
This is a likely candidate for rewriting in C, as it
is called for every almost function in the system!
"""
if self.CurrentContextIsValid():
return glGetError()
return None
def GLU(self):
try:
return ctypesloader.loadLibrary(ctypes.cdll,
'GLU',
mode=ctypes.RTLD_GLOBAL)
except OSError:
return None
def GLU(self):
try:
return ctypesloader.loadLibrary(ctypes.windll,
"glu32",
mode=ctypes.RTLD_GLOBAL)
except OSError:
return None
def GLES2(self):
try:
return ctypesloader.loadLibrary(ctypes.cdll,
"GLESv2",
mode=ctypes.RTLD_GLOBAL)
except OSError:
return None
def GL(self):
try:
return ctypesloader.loadLibrary(ctypes.cdll,
'OSMesa',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
raise ImportError("Unable to load OpenGL library", *err.args)
def GLE(self):
try:
return ctypesloader.loadLibrary(ctypes.cdll,
'gle',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
return None
class Win32Platform(baseplatform.BasePlatform):
"""Win32-specific platform implementation"""
GLUT_GUARD_CALLBACKS = True
GL = OpenGL = ctypesloader.loadLibrary(ctypes.windll,
'opengl32',
mode=ctypes.RTLD_GLOBAL)
GLU = ctypesloader.loadLibrary(ctypes.windll,
'glu32',
mode=ctypes.RTLD_GLOBAL)
try:
GLUT = ctypesloader.loadLibrary(ctypes.windll,
'glut32',
mode=ctypes.RTLD_GLOBAL)
except WindowsError, err:
GLUT = None
def GLU(self):
try:
return ctypesloader.loadLibrary(
ctypes.windll, 'glu32', mode = ctypes.RTLD_GLOBAL
)
except OSError as err:
return None
def GL(self):
try:
return ctypesloader.loadLibrary(
ctypes.windll, 'opengl32', mode = ctypes.RTLD_GLOBAL
)
except OSError as err:
raise ImportError("Unable to load OpenGL library", *err.args)
def GL(self):
try:
return ctypesloader.loadLibrary(ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
return self.GLES2 or self.GLES1
def getScreen( self, display ):
from OpenGL.platform import ctypesloader
from OpenGL.raw.GLX import _types
import ctypes, os
X11 = ctypesloader.loadLibrary( ctypes.cdll, 'X11' )
XDefaultScreen = X11.XDefaultScreen
XDefaultScreen.argtypes = [ctypes.POINTER(_types.Display)]
return XDefaultScreen( display )
def getDisplay( self ):
from OpenGL.raw.GLX import _types
from OpenGL.platform import ctypesloader
import ctypes, os
X11 = ctypesloader.loadLibrary( ctypes.cdll, 'X11' )
XOpenDisplay = X11.XOpenDisplay
XOpenDisplay.restype = ctypes.POINTER(_types.Display)
return XOpenDisplay( os.environ.get( 'DISPLAY' ))
class GLXPlatform(baseplatform.BasePlatform):
"""Posix (Linux, FreeBSD, etceteras) implementation for PyOpenGL"""
# On Linux (and, I assume, most GLX platforms, we have to load
# GL and GLU with the "global" flag to allow GLUT to resolve its
# references to GL/GLU functions).
GL = OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL)
GLU = ctypesloader.loadLibrary(ctypes.cdll, 'GLU', mode=ctypes.RTLD_GLOBAL)
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
try:
GLUT = ctypesloader.loadLibrary(ctypes.cdll,
'glut',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
GLUT = None
def GLES1(self):
try:
return ctypesloader.loadLibrary(
ctypes.cdll,
'GLESv1_CM', # ick
mode=ctypes.RTLD_GLOBAL)
except OSError:
return None
def getDisplay(self):
from OpenGL.raw.GLX import _types
from OpenGL.platform import ctypesloader
import ctypes, os
X11 = ctypesloader.loadLibrary(ctypes.cdll, "X11")
XOpenDisplay = X11.XOpenDisplay
XOpenDisplay.restype = ctypes.POINTER(_types.Display)
return XOpenDisplay(os.environ.get("DISPLAY"))
def getScreen(self, display):
from OpenGL.platform import ctypesloader
from OpenGL.raw.GLX import _types
import ctypes, os
X11 = ctypesloader.loadLibrary(ctypes.cdll, "X11")
XDefaultScreen = X11.XDefaultScreen
XDefaultScreen.argtypes = [ctypes.POINTER(_types.Display)]
return XDefaultScreen(display)
class OSMesaPlatform(baseplatform.BasePlatform):
"""OSMesa implementation for PyOpenGL"""
try:
GL = OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'OSMesa',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
def GLES1(self):
try:
return ctypesloader.loadLibrary(
ctypes.cdll,
'GLESv1_CM', # ick
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
return None
def EGL(self):
try:
return ctypesloader.loadLibrary(
ctypes.cdll,
'EGL',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
raise ImportError("Unable to load EGL library", *err.args)
def GL(self):
try:
return ctypesloader.loadLibrary(
ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
return self.GLES2 or self.GLES1
def GLUT(self):
for possible in ("freeglut%s.%s" % (size, vc), "glut%s.%s" % (size, vc)):
# Prefer FreeGLUT if the user has installed it, fallback to the included
# GLUT if it is installed
try:
return ctypesloader.loadLibrary(ctypes.windll, possible, mode=ctypes.RTLD_GLOBAL)
except WindowsError:
pass
return None
def GLUT( self ):
try:
return ctypesloader.loadLibrary(
ctypes.cdll,
'GLUT',
mode=ctypes.RTLD_GLOBAL
)
except OSError:
return None
class Win32Platform(baseplatform.BasePlatform):
"""Win32-specific platform implementation"""
GLUT_GUARD_CALLBACKS = True
try:
GL = OpenGL = ctypesloader.loadLibrary(ctypes.windll,
'opengl32',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
def GLUT( self ):
for possible in ('freeglut%s.%s'%(size,vc,), 'glut%s.%s'%(size,vc,)):
# Prefer FreeGLUT if the user has installed it, fallback to the included
# GLUT if it is installed
try:
return ctypesloader.loadLibrary(
ctypes.windll, possible, mode = ctypes.RTLD_GLOBAL
)
except WindowsError:
pass
return None
def GLE(self):
for libName in ("gle%s.%s" % (size, vc), "opengle%s.%s" % (size, vc)):
try:
GLE = ctypesloader.loadLibrary(ctypes.cdll, libName)
GLE.FunctionType = ctypes.CFUNCTYPE
return GLE
except WindowsError:
pass
else:
break
return None
def GLE( self ):
for libName in ('gle%s.%s'%(size,vc,), 'opengle%s.%s'%(size,vc,)):
try:
GLE = ctypesloader.loadLibrary( ctypes.cdll, libName )
GLE.FunctionType = ctypes.CFUNCTYPE
return GLE
except WindowsError:
pass
else:
break
return None
class GLXPlatform(baseplatform.BasePlatform):
"""Posix (Linux, FreeBSD, etceteras) implementation for PyOpenGL"""
# On Linux (and, I assume, most GLX platforms, we have to load
# GL and GLU with the "global" flag to allow GLUT to resolve its
# references to GL/GLU functions).
try:
GL = OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
def GL(self):
try:
for name in ('OpenGL', 'GL'):
lib = ctypesloader.loadLibrary(ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL)
if lib:
return lib
raise OSError("No GL/OpenGL library available")
except OSError:
return self.GLES2 or self.GLES1
class DarwinPlatform(baseplatform.BasePlatform):
"""Darwin (OSX) platform implementation"""
DEFAULT_FUNCTION_TYPE = staticmethod(ctypes.CFUNCTYPE)
EXTENSIONS_USE_BASE_FUNCTIONS = True
# Get the pointers to the libraries...
try:
OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'OpenGL',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
class Win32Platform(baseplatform.BasePlatform):
"""Win32-specific platform implementation"""
GLUT_GUARD_CALLBACKS = True
GL = OpenGL = ctypesloader.loadLibrary(ctypes.windll,
'opengl32',
mode=ctypes.RTLD_GLOBAL)
GLU = ctypesloader.loadLibrary(ctypes.windll,
'glu32',
mode=ctypes.RTLD_GLOBAL)
GLUT = None
for possible in ('glut32', 'freeglut32', 'freeglut'):
# load first-up of the possible names...
try:
GLUT = ctypesloader.loadLibrary(ctypes.windll,
possible,
mode=ctypes.RTLD_GLOBAL)
except WindowsError, err:
GLUT = None
else:
break
def EGL(self):
# TODO: the raspberry pi crashes on trying to load EGL module
# because the EGL library requires a structure from GLES2 without
# linking to that library... Github issue is here:
# https://github.com/raspberrypi/firmware/issues/110
import os
if os.path.exists('/proc/cpuinfo'):
info = open('/proc/cpuinfo').read()
if 'BCM2708' in info or 'BCM2709' in info:
assert self.GLES2
try:
return ctypesloader.loadLibrary(ctypes.cdll,
'EGL',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
raise ImportError("Unable to load EGL library", *err.args)
def EGL(self):
# TODO: the raspberry pi crashes on trying to load EGL module
# because the EGL library requires a structure from GLES2 without
# linking to that library... Github issue is here:
# https://github.com/raspberrypi/firmware/issues/110
import os
if os.path.exists('/proc/cpuinfo'):
info = open('/proc/cpuinfo').read()
if 'BCM2708' in info or 'BCM2709' in info:
assert self.GLES2
try:
return ctypesloader.loadLibrary(
ctypes.cdll,
'EGL',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
raise ImportError("Unable to load EGL library", *err.args)
class GLXPlatform(baseplatform.BasePlatform):
"""Posix (Linux, FreeBSD, etceteras) implementation for PyOpenGL"""
# On Linux (and, I assume, most GLX platforms, we have to load
# GL and GLU with the "global" flag to allow GLUT to resolve its
# references to GL/GLU functions).
try:
GL = OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
raise ImportError("Unable to load OpenGL library", *err.args)
try:
GLU = ctypesloader.loadLibrary(ctypes.cdll,
'GLU',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
GLU = None
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
try:
GLUT = ctypesloader.loadLibrary(ctypes.cdll,
'glut',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
GLUT = None
# GLX doesn't seem to have its own loadable module?
GLX = GL
glXGetProcAddressARB = GL.glXGetProcAddressARB
glXGetProcAddressARB.restype = ctypes.c_void_p
getExtensionProcedure = staticmethod(glXGetProcAddressARB)
try:
GLE = ctypesloader.loadLibrary(ctypes.cdll,
'gle',
mode=ctypes.RTLD_GLOBAL)
except OSError as err:
GLE = None
DEFAULT_FUNCTION_TYPE = staticmethod(ctypes.CFUNCTYPE)
# This loads the GLX functions from the GL .so, not sure if that's
# really kosher...
GetCurrentContext = CurrentContextIsValid = staticmethod(
GL.glXGetCurrentContext)
def getGLUTFontPointer(self, constant):
"""Platform specific function to retrieve a GLUT font pointer
GLUTAPI void *glutBitmap9By15;
#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15)
Key here is that we want the addressof the pointer in the DLL,
not the pointer in the DLL. That is, our pointer is to the
pointer defined in the DLL, we don't want the *value* stored in
that pointer.
"""
name = [x.title() for x in constant.split('_')[1:]]
internal = 'glut' + "".join([x.title() for x in name])
pointer = ctypes.c_void_p.in_dll(self.GLUT, internal)
return ctypes.c_void_p(ctypes.addressof(pointer))
safeGetError = staticmethod(OpenGL.glGetError)
"""Utility module for interacting with GBM to select rendering device
The base code here comes from github bug report #6 in the pyopengl
project, thanks to @abandoned-cocoon for that.
"""
import weakref, ctypes, logging, os, glob
from OpenGL.platform import ctypesloader
from OpenGL import _opaque
log = logging.getLogger(__name__)
gbm = ctypesloader.loadLibrary(ctypes.CDLL,"gbm")
__all__ = ("enumerate_devices","open_device","close_device","gbm")
_DEVICE_HANDLES = {}
GBM_BO_USE_SCANOUT = (1 << 0)
GBM_BO_USE_CURSOR = (1 << 1)
GBM_BO_USE_CURSOR_64X64 = GBM_BO_USE_CURSOR
GBM_BO_USE_RENDERING = (1 << 2)
GBM_BO_USE_WRITE = (1 << 3)
GBM_BO_USE_LINEAR = (1 << 4)
GBMDevice = _opaque.opaque_pointer_cls("GBMDevice")
GBMSurface = _opaque.opaque_pointer_cls("GBMSurface")
gbm.gbm_create_device.restype = GBMDevice
gbm.gbm_surface_create.restype = GBMSurface
def filter_bad_drivers(cards, bad_drivers=("nvidia",)):
"""Lookup the driver for each card to exclude loading nvidia devices"""
# this is pci specific, which I suppose means we"re going to fail
# if the GPU isn"t on the PCI bus, but we don"t seem to have
# another way to match up the card to the driver :(
bad_cards = set()
for link in glob.glob("/dev/dri/by-path/pci-*-card"):
GL = OpenGL = ctypesloader.loadLibrary(ctypes.windll,
'opengl32',
mode=ctypes.RTLD_GLOBAL)
GLU = ctypesloader.loadLibrary(ctypes.windll,
'glu32',
mode=ctypes.RTLD_GLOBAL)
try:
GLUT = ctypesloader.loadLibrary(ctypes.windll,
'glut32',
mode=ctypes.RTLD_GLOBAL)
except WindowsError, err:
GLUT = None
GLE = None
for libName in ('gle32', 'opengle32'):
try:
GLE = ctypesloader.loadLibrary(ctypes.cdll, libName)
GLE.FunctionType = ctypes.CFUNCTYPE
except WindowsError, err:
pass
else:
break
DEFAULT_FUNCTION_TYPE = staticmethod(ctypes.WINFUNCTYPE)
# Win32 GLUT uses different types for callbacks and functions...
GLUT_CALLBACK_TYPE = staticmethod(ctypes.CFUNCTYPE)
WGL = ctypes.windll.gdi32
getExtensionProcedure = staticmethod(OpenGL.wglGetProcAddress)
GLUT_FONT_CONSTANTS = {
'GLUT_STROKE_ROMAN': ctypes.c_void_p(0),
'GLUT_STROKE_MONO_ROMAN': ctypes.c_void_p(1),
OpenGL = ctypesloader.loadLibrary(
ctypes.cdll,
'OpenGL',
mode=ctypes.RTLD_GLOBAL
)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
# CGL provides the windowing environment functionality
# but it is built into the GL libs.
GL = GLU = CGL = OpenGL
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
GLUT = ctypesloader.loadLibrary(
ctypes.cdll,
'GLUT',
mode=ctypes.RTLD_GLOBAL
)
# GLE is handled by GLUT under OS X
GLE = GLUT
GetCurrentContext = CurrentContextIsValid = staticmethod(
CGL.CGLGetCurrentContext
)
def getGLUTFontPointer( self, constant ):
"""Platform specific function to retrieve a GLUT font pointer
GLUTAPI void *glutBitmap9By15;
#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15)
GLUT = ctypesloader.loadLibrary( ctypes.cdll, 'glut', mode=ctypes.RTLD_GLOBAL ) except OSError, err: GLUT = None # GLX doesn't seem to have its own loadable module? GLX = GL glXGetProcAddressARB = GL.glXGetProcAddressARB glXGetProcAddressARB.restype = ctypes.c_void_p getExtensionProcedure = staticmethod( glXGetProcAddressARB ) try: GLE = ctypesloader.loadLibrary( ctypes.cdll, 'gle', mode=ctypes.RTLD_GLOBAL ) except OSError, err: GLE = None DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE ) # This loads the GLX functions from the GL .so, not sure if that's # really kosher... GetCurrentContext = CurrentContextIsValid = staticmethod( GL.glXGetCurrentContext ) def getGLUTFontPointer( self, constant ):
class Win32Platform( baseplatform.BasePlatform ):
"""Win32-specific platform implementation"""
GLUT_GUARD_CALLBACKS = True
try:
GL = OpenGL = ctypesloader.loadLibrary(
ctypes.windll, 'opengl32', mode = ctypes.RTLD_GLOBAL
)
except OSError as err:
raise ImportError("Unable to load OpenGL library", *err.args)
try:
GLU = ctypesloader.loadLibrary(
ctypes.windll, 'glu32', mode = ctypes.RTLD_GLOBAL
)
except OSError as err:
GLU = None
GLUT = None
for possible in ('freeglut%s.%s'%(size,vc,), 'glut%s.%s'%(size,vc,), 'freeglut'):
# Prefer FreeGLUT if the user has installed it, fallback to the included
# GLUT if it is installed
try:
GLUT = ctypesloader.loadLibrary(
ctypes.windll, possible, mode = ctypes.RTLD_GLOBAL
)
except WindowsError as err:
GLUT = None
else:
break
try:
del possible
except NameError as err:
pass
GLE = None
for libName in ('gle%s.%s'%(size,vc,), 'opengle%s.%s'%(size,vc,)):
try:
GLE = ctypesloader.loadLibrary( ctypes.cdll, libName )
GLE.FunctionType = ctypes.CFUNCTYPE
except WindowsError as err:
pass
else:
break
DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.WINFUNCTYPE )
# Win32 GLUT uses different types for callbacks and functions...
GLUT_CALLBACK_TYPE = staticmethod( ctypes.CFUNCTYPE )
WGL = ctypes.windll.gdi32
getExtensionProcedure = staticmethod( OpenGL.wglGetProcAddress )
GLUT_FONT_CONSTANTS = {
'GLUT_STROKE_ROMAN': ctypes.c_void_p( 0),
'GLUT_STROKE_MONO_ROMAN': ctypes.c_void_p( 1),
'GLUT_BITMAP_9_BY_15': ctypes.c_void_p( 2),
'GLUT_BITMAP_8_BY_13': ctypes.c_void_p( 3),
'GLUT_BITMAP_TIMES_ROMAN_10': ctypes.c_void_p( 4),
'GLUT_BITMAP_TIMES_ROMAN_24': ctypes.c_void_p( 5),
'GLUT_BITMAP_HELVETICA_10': ctypes.c_void_p( 6),
'GLUT_BITMAP_HELVETICA_12': ctypes.c_void_p( 7),
'GLUT_BITMAP_HELVETICA_18': ctypes.c_void_p( 8),
}
def getGLUTFontPointer( self,constant ):
"""Platform specific function to retrieve a GLUT font pointer
GLUTAPI void *glutBitmap9By15;
#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15)
Key here is that we want the addressof the pointer in the DLL,
not the pointer in the DLL. That is, our pointer is to the
pointer defined in the DLL, we don't want the *value* stored in
that pointer.
"""
return self.GLUT_FONT_CONSTANTS[ constant ]
GetCurrentContext = CurrentContextIsValid = staticmethod(
GL.wglGetCurrentContext
)
def safeGetError( self ):
"""Provide context-not-present-safe error-checking
Under OS-X an attempt to retrieve error without checking
context will bus-error. Likely Windows will see the same.
This function checks for a valid context before running
glGetError
Note:
This is a likely candidate for rewriting in C, as it
is called for every almost function in the system!
"""
if self.CurrentContextIsValid():
return glGetError()
return None
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Extends OpenGL.EGL with definitions necessary for headless rendering."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import ctypes
from OpenGL.platform import ctypesloader # pylint: disable=g-bad-import-order
try:
# Nvidia driver seems to need libOpenGL.so (as opposed to libGL.so)
# for multithreading to work properly. We load this in before everything else.
ctypesloader.loadLibrary(ctypes.cdll, 'OpenGL', mode=ctypes.RTLD_GLOBAL)
except OSError:
pass
# pylint: disable=g-import-not-at-top
from OpenGL import EGL
from OpenGL import error
from six.moves import range
# From the EGL_EXT_device_enumeration extension.
EGLDeviceEXT = ctypes.c_void_p
PFNEGLQUERYDEVICESEXTPROC = ctypes.CFUNCTYPE(EGL.EGLBoolean, EGL.EGLint,
ctypes.POINTER(EGLDeviceEXT),
ctypes.POINTER(EGL.EGLint))
try:
raise SystemExit(1)
attributes = [
# GLX_BIND_TO_TEXTURE_RGBA_EXT, 1,
# GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
# GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
GLX_DOUBLEBUFFER,
0,
# GLX_Y_INVERTED_EXT, GLX_DONT_CARE,
GL_NONE,
]
attributes = (GLint * len(attributes))(*attributes)
import ctypes
from OpenGL.platform import ctypesloader
X11 = ctypesloader.loadLibrary(ctypes.cdll, "X11")
XDefaultScreen = X11.XDefaultScreen
XDefaultScreen.argtypes = [ctypes.POINTER(Display)]
XOpenDisplay = X11.XOpenDisplay
XOpenDisplay.restype = ctypes.POINTER(Display)
XRootWindow = X11.XRootWindow
XRootWindow.restyle = ctypes.POINTER(Window)
XCreateWindow = X11.XCreateWindow
XCreateWindow.restyle = ctypes.POINTER(Window)
XCreateWindow.argtypes = [
ctypes.POINTER(Display),
ctypes.POINTER(Window),
import os
attributes = [
# GLX_BIND_TO_TEXTURE_RGBA_EXT, 1,
# GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT,
# GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
GLX_DOUBLEBUFFER, 1,
# GLX_Y_INVERTED_EXT, GLX_DONT_CARE,
GL_NONE
]
#from OpenGL import platform
import ctypes
from OpenGL.platform import ctypesloader
X11 = ctypesloader.loadLibrary( ctypes.cdll, 'X11' )
XDefaultScreen = X11.XDefaultScreen
XDefaultScreen.argtypes = [ctypes.POINTER(Display)]
XOpenDisplay = X11.XOpenDisplay
XOpenDisplay.restype = ctypes.POINTER(Display)
@pygametest()
def main():
dsp = XOpenDisplay( os.environ.get( 'DISPLAY' ))
screen = XDefaultScreen( dsp )
print('X Display %s Screen %s'%( dsp, screen ))
major,minor = GLint(),GLint()
glXQueryVersion(dsp, major, minor)
version = (major.value,minor.value)
print('glX Version: %s.%s'%version)
if version >= (1,1):
"""Posix (Linux, FreeBSD, etceteras) implementation for PyOpenGL"""
# On Linux (and, I assume, most GLX platforms, we have to load
# GL and GLU with the "global" flag to allow GLUT to resolve its
# references to GL/GLU functions).
try:
GL = OpenGL = ctypesloader.loadLibrary(
ctypes.cdll,
'GL',
mode=ctypes.RTLD_GLOBAL
)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
try:
GLU = ctypesloader.loadLibrary(
ctypes.cdll,
'GLU',
mode=ctypes.RTLD_GLOBAL
)
except OSError, err:
GLU = None
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
try:
GLUT = ctypesloader.loadLibrary(
ctypes.cdll,
'glut',
mode=ctypes.RTLD_GLOBAL
)
except OSError, err:
GLUT = None
# GLX doesn't seem to have its own loadable module?
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
try:
GLUT = ctypesloader.loadLibrary(ctypes.cdll,
'glut',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
GLUT = None
# GLX doesn't seem to have its own loadable module?
GLX = GL
glXGetProcAddressARB = GL.glXGetProcAddressARB
glXGetProcAddressARB.restype = ctypes.c_void_p
getExtensionProcedure = staticmethod(glXGetProcAddressARB)
try:
GLE = ctypesloader.loadLibrary(ctypes.cdll,
'gle',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
GLE = None
DEFAULT_FUNCTION_TYPE = staticmethod(ctypes.CFUNCTYPE)
# This loads the GLX functions from the GL .so, not sure if that's
# really kosher...
GetCurrentContext = CurrentContextIsValid = staticmethod(
GL.glXGetCurrentContext)
def getGLUTFontPointer(self, constant):
"""Platform specific function to retrieve a GLUT font pointer
GLUTAPI void *glutBitmap9By15;
import ctypes, ctypes.util
from OpenGL.platform import baseplatform, ctypesloader
from OpenGL.constant import Constant
class OSMesaPlatform(baseplatform.BasePlatform):
"""OSMesa implementation for PyOpenGL"""
try:
GL = OpenGL = ctypesloader.loadLibrary(ctypes.cdll,
'OSMesa',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
try:
GLU = ctypesloader.loadLibrary(ctypes.cdll,
'GLU',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
GLU = None
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
try:
GLUT = ctypesloader.loadLibrary(ctypes.cdll,
'glut',
mode=ctypes.RTLD_GLOBAL)
except OSError, err:
GLUT = None
try:
GLE = ctypesloader.loadLibrary(ctypes.cdll,
'gle',
class Win32Platform( baseplatform.BasePlatform ):
"""Win32-specific platform implementation"""
GLUT_GUARD_CALLBACKS = True
try:
GL = OpenGL = ctypesloader.loadLibrary(
ctypes.windll, 'opengl32', mode = ctypes.RTLD_GLOBAL
)
except OSError, err:
raise ImportError("Unable to load OpenGL library", *err.args)
try:
GLU = ctypesloader.loadLibrary(
ctypes.windll, 'glu32', mode = ctypes.RTLD_GLOBAL
)
except OSError, err:
GLU = None
GLUT = None
for possible in ('glut32','freeglut32','freeglut'):
# load first-up of the possible names...
try:
GLUT = ctypesloader.loadLibrary(
ctypes.windll, possible, mode = ctypes.RTLD_GLOBAL
)
except WindowsError, err:
GLUT = None
else:
break
class OSMesaPlatform( baseplatform.BasePlatform ):
"""OSMesa implementation for PyOpenGL"""
try:
GL = OpenGL = ctypesloader.loadLibrary(
ctypes.cdll,
'OSMesa',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
raise ImportError("Unable to load OpenGL library", *err.args)
try:
GLU = ctypesloader.loadLibrary(
ctypes.cdll,
'GLU',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
GLU = None
# glut shouldn't need to be global, but just in case a dependent library makes
# the same assumption GLUT does...
try:
GLUT = ctypesloader.loadLibrary(
ctypes.cdll,
'glut',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
GLUT = None
try:
GLE = ctypesloader.loadLibrary(
ctypes.cdll,
'gle',
mode=ctypes.RTLD_GLOBAL
)
except OSError as err:
GLE = None
DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.CFUNCTYPE )
GLenum = ctypes.c_uint
GLboolean = ctypes.c_ubyte
GLsizei = ctypes.c_int
GLint = ctypes.c_int
baseplatform.BasePlatform.EXPORTED_NAMES += ['OSMesaCreateContext',
'OSMesaCreateContextExt', 'OSMesaMakeCurrent', 'OSMesaGetIntegerv',
'OSMesaGetCurrentContext', 'OSMesaDestroyContext', 'OSMesaPixelStore',
'OSMesaGetDepthBuffer', 'OSMesaGetColorBuffer',
'OSMESA_COLOR_INDEX', 'OSMESA_RGBA', 'OSMESA_BGRA', 'OSMESA_ARGB',
'OSMESA_RGB', 'OSMESA_BGR', 'OSMESA_BGR', 'OSMESA_ROW_LENGTH',
'OSMESA_Y_UP', 'OSMESA_WIDTH', 'OSMESA_HEIGHT', 'OSMESA_FORMAT',
'OSMESA_TYPE', 'OSMESA_MAX_WIDTH', 'OSMESA_MAX_HEIGHT']
# export OSMesa functions from osmesa.h
class struct_osmesa_context(ctypes.Structure):
__slots__ = [
]
struct_osmesa_context._fields_ = [
('_opaque_struct', ctypes.c_int)
]
OSMesaContext = ctypes.POINTER(struct_osmesa_context)
# Values for the format parameter of OSMesaCreateContext()
OSMESA_COLOR_INDEX = Constant('OSMESA_COLOR_INDEX', 6400)
OSMESA_RGBA = Constant('OSMESA_RGBA', 6408)
OSMESA_BGRA = Constant('OSMESA_BGRA', 0x1)
OSMESA_ARGB = Constant('OSMESA_ARGB', 0x2)
OSMESA_RGB = Constant('OSMESA_RGB', 6407)
OSMESA_BGR = Constant('OSMESA_BGR', 0x4)
OSMESA_RGB_565 = Constant('OSMESA_BGR', 0x5)
# OSMesaPixelStore() parameters:
OSMESA_ROW_LENGTH = Constant('OSMESA_ROW_LENGTH', 0x10)
OSMESA_Y_UP = Constant('OSMESA_Y_UP', 0x11)
# Accepted by OSMesaGetIntegerv:
OSMESA_WIDTH = Constant('OSMESA_WIDTH', 0x20)
OSMESA_HEIGHT = Constant('OSMESA_HEIGHT', 0x21)
OSMESA_FORMAT = Constant('OSMESA_FORMAT', 0x22)
OSMESA_TYPE = Constant('OSMESA_TYPE', 0x23)
OSMESA_MAX_WIDTH = Constant('OSMESA_MAX_WIDTH', 0x24)
OSMESA_MAX_HEIGHT = Constant('OSMESA_MAX_HEIGHT', 0x25)
OSMesaCreateContext = GL.OSMesaCreateContext
OSMesaCreateContext.argtypes = [GLenum, OSMesaContext]
OSMesaCreateContext.restype = OSMesaContext
OSMesaCreateContextExt = GL.OSMesaCreateContextExt
OSMesaCreateContextExt.argtypes = [GLenum, GLint, GLint, GLint,
OSMesaContext]
OSMesaCreateContextExt.restype = OSMesaContext
OSMesaDestroyContext = GL.OSMesaDestroyContext
OSMesaDestroyContext.argtypes = [OSMesaContext]
OSMesaMakeCurrent = GL.OSMesaMakeCurrent
OSMesaMakeCurrent.argtypes = [OSMesaContext, ctypes.POINTER(None),
GLenum, GLsizei, GLsizei]
OSMesaMakeCurrent.restype = GLboolean
OSMesaGetCurrentContext = GL.OSMesaGetCurrentContext
#OSMesaGetCurrentContext.restype = OSMesaContext
GetCurrentContext = CurrentContextIsValid = OSMesaGetCurrentContext
OSMesaPixelStore = GL.OSMesaPixelStore
OSMesaPixelStore.argtypes = [GLint, GLint]
OSMesaPixelStore.restype = None
OSMesaGetProcAddress = GL.OSMesaGetProcAddress
OSMesaGetProcAddress.restype = ctypes.c_void_p
getExtensionProcedure = staticmethod( OSMesaGetProcAddress )
def OSMesaGetIntegerv(self, pname):
value = self.GLint()
self.GL.OSMesaGetIntegerv(pname, ctypes.byref(value))
return value.value
def OSMesaGetDepthBuffer(self, c):
width, height, bytesPerValue = self.GLint(), self.GLint(), self.GLint()
buffer = ctypes.POINTER(self.GLint)()
if self.GL.OSMesaGetDepthBuffer(c, ctypes.byref(width),
ctypes.byref(height),
ctypes.byref(bytesPerValue),
ctypes.byref(buffer)):
return width.value, height.value, bytesPerValue.value, buffer
else:
return 0, 0, 0, None
def OSMesaGetColorBuffer(self, c):
# TODO: make output array types which can handle the operation
# provide an API to convert pointers + sizes to array instances,
# e.g. numpy.ctypeslib.as_array( ptr, bytesize ).astype( 'B' ).reshape( height,width )
width, height, format = self.GLint(), self.GLint(), self.GLint()
buffer = ctypes.c_void_p()
if self.GL.OSMesaGetColorBuffer(c, ctypes.byref(width),
ctypes.byref(height),
ctypes.byref(format),
ctypes.byref(buffer)):
return width.value, height.value, format.value, buffer
else:
return 0, 0, 0, None
def getGLUTFontPointer( self, constant ):
"""Platform specific function to retrieve a GLUT font pointer
GLUTAPI void *glutBitmap9By15;
#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15)
Key here is that we want the addressof the pointer in the DLL,
not the pointer in the DLL. That is, our pointer is to the
pointer defined in the DLL, we don't want the *value* stored in
that pointer.
"""
name = [ x.title() for x in constant.split( '_' )[1:] ]
internal = 'glut' + "".join( [x.title() for x in name] )
pointer = ctypes.c_void_p.in_dll( self.GLUT, internal )
return ctypes.c_void_p(ctypes.addressof(pointer))
safeGetError = staticmethod( OpenGL.glGetError )
from OpenGL.platform import ctypesloader, baseplatform
class Win32Platform( baseplatform.BasePlatform ):
"""Win32-specific platform implementation"""
GLUT_GUARD_CALLBACKS = True
GL = OpenGL = ctypesloader.loadLibrary( ctypes.windll, 'opengl32', mode = ctypes.RTLD_GLOBAL )
GLU = ctypesloader.loadLibrary( ctypes.windll, 'glu32', mode = ctypes.RTLD_GLOBAL )
try:
GLUT = ctypesloader.loadLibrary( ctypes.windll, 'glut32', mode = ctypes.RTLD_GLOBAL )
except WindowsError, err:
GLUT = None
GLE = None
for libName in ('gle32','opengle32'):
try:
GLE = ctypesloader.loadLibrary( ctypes.cdll, libName )
GLE.FunctionType = ctypes.CFUNCTYPE
except WindowsError, err:
pass
else:
break
DEFAULT_FUNCTION_TYPE = staticmethod( ctypes.WINFUNCTYPE )
# Win32 GLUT uses different types for callbacks and functions...
GLUT_CALLBACK_TYPE = staticmethod( ctypes.CFUNCTYPE )
WGL = ctypes.windll.gdi32
getExtensionProcedure = staticmethod( OpenGL.wglGetProcAddress )
GLUT_FONT_CONSTANTS = {
'GLUT_STROKE_ROMAN': ctypes.c_void_p( 0),
'GLUT_STROKE_MONO_ROMAN': ctypes.c_void_p( 1),
