PyOpenGL 3.1.7__tar.gz → 3.1.9__tar.gz

pyopengl-3.1.9/OpenGL/EGL/debug.py

@@ -0,0 +1,246 @@
+"""Debug utilities for EGL operations"""
+
+from OpenGL.EGL import *
+import itertools
+
+
+def eglErrorName(value):
+    """Returns error constant if known, otherwise returns value"""
+    return KNOWN_ERRORS.get(value, value)
+
+
+KNOWN_ERRORS = {
+    EGL_SUCCESS: EGL_SUCCESS,
+    EGL_NOT_INITIALIZED: EGL_NOT_INITIALIZED,
+    EGL_BAD_ACCESS: EGL_BAD_ACCESS,
+    EGL_BAD_ALLOC: EGL_BAD_ALLOC,
+    EGL_BAD_ATTRIBUTE: EGL_BAD_ATTRIBUTE,
+    EGL_BAD_CONTEXT: EGL_BAD_CONTEXT,
+    EGL_BAD_CONFIG: EGL_BAD_CONFIG,
+    EGL_BAD_CURRENT_SURFACE: EGL_BAD_CURRENT_SURFACE,
+    EGL_BAD_DISPLAY: EGL_BAD_DISPLAY,
+    EGL_BAD_SURFACE: EGL_BAD_SURFACE,
+    EGL_BAD_MATCH: EGL_BAD_MATCH,
+    EGL_BAD_PARAMETER: EGL_BAD_PARAMETER,
+    EGL_BAD_NATIVE_PIXMAP: EGL_BAD_NATIVE_PIXMAP,
+    EGL_BAD_NATIVE_WINDOW: EGL_BAD_NATIVE_WINDOW,
+    EGL_CONTEXT_LOST: EGL_CONTEXT_LOST,
+}
+
+
+def write_ppm(buf, filename):
+    """Write height * width * 3-component buffer as ppm to filename
+
+    This lets us write a simple image format without
+    using any libraries that can be viewed on most
+    linux workstations.
+    """
+    with open(filename, "w") as f:
+        (h, w, c) = buf.shape
+        f.write("P3\n")
+        f.write("# ascii ppm file created by pyopengl\n")
+        f.write("%i %i\n" % (w, h))
+        f.write("255\n")
+        for y in range(h - 1, -1, -1):
+            for x in range(w):
+                pixel = buf[y, x]
+                l = " %3d %3d %3d" % (pixel[0], pixel[1], pixel[2])
+                f.write(l)
+            f.write("\n")
+
+
+def debug_config(display, config):
+    """Get debug display for the given configuration"""
+    result = {}
+    value = EGLint()
+    for attr in CONFIG_ATTRS:
+        if not eglGetConfigAttrib(display, config, attr, value):
+            log.warning("Failed to get attribute %s from config", attr)
+            continue
+        if attr in BITMASK_FIELDS:
+            attr_value = {}
+            for subattr in BITMASK_FIELDS[attr]:
+                if value.value & subattr:
+                    attr_value[subattr.name] = True
+        else:
+            attr_value = value.value
+        result[attr.name] = attr_value
+    return result
+
+
+def debug_configs(display, configs=None, max_count=256):
+    """Present a formatted list of configs for the display"""
+    if configs is None:
+        configs = (EGLConfig * max_count)()
+        num_configs = EGLint()
+        eglGetConfigs(display, configs, max_count, num_configs)
+        if not num_configs.value:
+            return []
+        configs = configs[: num_configs.value]
+    debug_configs = [debug_config(display, cfg) for cfg in configs]
+    return debug_configs
+
+
+SURFACE_TYPE_BITS = [
+    EGL_MULTISAMPLE_RESOLVE_BOX_BIT,
+    EGL_PBUFFER_BIT,
+    EGL_PIXMAP_BIT,
+    EGL_SWAP_BEHAVIOR_PRESERVED_BIT,
+    EGL_VG_ALPHA_FORMAT_PRE_BIT,
+    EGL_VG_COLORSPACE_LINEAR_BIT,
+    EGL_WINDOW_BIT,
+]
+RENDERABLE_TYPE_BITS = [
+    EGL_OPENGL_BIT,
+    EGL_OPENGL_ES_BIT,
+    EGL_OPENGL_ES2_BIT,
+    EGL_OPENGL_ES3_BIT,
+    EGL_OPENVG_BIT,
+]
+CAVEAT_BITS = [
+    EGL_NONE,
+    EGL_SLOW_CONFIG,
+    EGL_NON_CONFORMANT_CONFIG,
+]
+TRANSPARENT_BITS = [
+    EGL_NONE,
+    EGL_TRANSPARENT_RGB,
+]
+
+CONFIG_ATTRS = [
+    EGL_CONFIG_ID,
+    EGL_RED_SIZE,
+    EGL_GREEN_SIZE,
+    EGL_BLUE_SIZE,
+    EGL_DEPTH_SIZE,
+    EGL_ALPHA_SIZE,
+    EGL_ALPHA_MASK_SIZE,
+    EGL_BUFFER_SIZE,
+    EGL_STENCIL_SIZE,
+    EGL_BIND_TO_TEXTURE_RGB,
+    EGL_BIND_TO_TEXTURE_RGBA,
+    EGL_COLOR_BUFFER_TYPE,
+    EGL_CONFIG_CAVEAT,
+    EGL_CONFORMANT,
+    EGL_LEVEL,
+    EGL_LUMINANCE_SIZE,
+    EGL_MAX_PBUFFER_WIDTH,
+    EGL_MAX_PBUFFER_HEIGHT,
+    EGL_MAX_PBUFFER_PIXELS,
+    EGL_MIN_SWAP_INTERVAL,
+    EGL_MAX_SWAP_INTERVAL,
+    EGL_NATIVE_RENDERABLE,
+    EGL_NATIVE_VISUAL_ID,
+    EGL_NATIVE_VISUAL_TYPE,
+    EGL_RENDERABLE_TYPE,
+    EGL_SAMPLE_BUFFERS,
+    EGL_SAMPLES,
+    EGL_SURFACE_TYPE,
+    EGL_TRANSPARENT_TYPE,
+    EGL_TRANSPARENT_RED_VALUE,
+    EGL_TRANSPARENT_GREEN_VALUE,
+    EGL_TRANSPARENT_BLUE_VALUE,
+]
+
+BITMASK_FIELDS = dict(
+    [
+        (EGL_SURFACE_TYPE, SURFACE_TYPE_BITS),
+        (EGL_RENDERABLE_TYPE, RENDERABLE_TYPE_BITS),
+        (EGL_CONFORMANT, RENDERABLE_TYPE_BITS),
+        (EGL_CONFIG_CAVEAT, CAVEAT_BITS),
+        (EGL_TRANSPARENT_TYPE, TRANSPARENT_BITS),
+    ]
+)
+
+
+def bit_renderer(bit):
+    def render(value):
+        if bit.name in value:
+            return " Y"
+        else:
+            return " ."
+
+    return render
+
+
+CONFIG_FORMAT = [
+    (EGL_CONFIG_ID, "0x%x", "id", "cfg"),
+    (EGL_BUFFER_SIZE, "%i", "sz", "bf"),
+    (EGL_LEVEL, "%i", "l", "lv"),
+    (EGL_RED_SIZE, "%i", "r", "cbuf"),
+    (EGL_GREEN_SIZE, "%i", "g", "cbuf"),
+    (EGL_BLUE_SIZE, "%i", "b", "cbuf"),
+    (EGL_ALPHA_SIZE, "%i", "a", "cbuf"),
+    (EGL_DEPTH_SIZE, "%i", "th", "dp"),
+    (EGL_STENCIL_SIZE, "%i", "t", "s"),
+    (EGL_SAMPLES, "%i", "ns", "mult"),
+    (EGL_SAMPLE_BUFFERS, "%i", "bu", "mult"),
+    (EGL_NATIVE_VISUAL_ID, "0x%x", "id", "visual"),
+    (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_BIT), "gl", "render"),
+    (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_ES_BIT), "es", "render"),
+    (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_ES2_BIT), "e2", "render"),
+    (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENGL_ES3_BIT), "e3", "render"),
+    (EGL_RENDERABLE_TYPE, bit_renderer(EGL_OPENVG_BIT), "vg", "render"),
+    (EGL_SURFACE_TYPE, bit_renderer(EGL_WINDOW_BIT), "wn", "surface"),
+    (EGL_SURFACE_TYPE, bit_renderer(EGL_PBUFFER_BIT), "pb", "surface"),
+    (EGL_SURFACE_TYPE, bit_renderer(EGL_PIXMAP_BIT), "px", "surface"),
+]
+
+
+def format_debug_configs(debug_configs, formats=CONFIG_FORMAT):
+    """Format config for compact debugging display
+
+    Produces a config summary display for a set of
+    debug_configs as a text-mode table.
+
+    Uses `formats` (default `CONFIG_FORMAT`) to determine
+    which fields are extracted and how they are formatted
+    along with the column/subcolum set to be rendered in
+    the overall header.
+
+    returns formatted ASCII table for display in debug
+    logs or utilities
+    """
+    columns = []
+    for key, format, subcol, col in formats:
+        column = []
+        max_width = 0
+        for row in debug_configs:
+            if isinstance(row, EGLConfig):
+                raise TypeError(row, "Call debug_config(display,config)")
+            try:
+                value = row[key.name]
+            except KeyError:
+                formatted = "_"
+            else:
+                if isinstance(format, str):
+                    formatted = format % (value)
+                else:
+                    formatted = format(value)
+            max_width = max((len(formatted), max_width))
+            column.append(formatted)
+        columns.append(
+            {
+                "rows": column,
+                "key": key,
+                "format": format,
+                "subcol": subcol,
+                "col": col,
+                "width": max_width,
+            }
+        )
+    headers = []
+    subheaders = []
+    rows = [headers, subheaders]
+    # last_column = None
+    # last_column_width = 0
+    for header, subcols in itertools.groupby(columns, lambda x: x["col"]):
+        subcols = list(subcols)
+        width = sum([col["width"] for col in subcols]) + (len(subcols) - 1)
+        headers.append(header.center(width, ".")[:width])
+    for column in columns:
+        subheaders.append(column["subcol"].rjust(column["width"])[: column["width"]])
+    rows.extend(
+        zip(*[[v.rjust(col["width"], " ") for v in col["rows"]] for col in columns])
+    )
+    return "\n".join([" ".join(row) for row in rows])

pyopengl-3.1.9/OpenGL/GL/AMD/debug_output.py

@@ -0,0 +1,88 @@
+'''OpenGL extension AMD.debug_output
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.debug_output to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows the GL to notify applications when various
+	debug events occur in contexts that have been created with the debug
+	flag, as provided by WGL_ARB_create_context and GLX_ARB_create_context.
+	
+	These events are represented in the form of enumerable messages with an
+	included human-readable translation.  Examples of debug events include
+	incorrect use of the GL, warnings of undefined behavior, and performance
+	warnings.
+	
+	A message is uniquely identified by a category and an implementation-
+	dependent ID within that category.  Message categories are general and are
+	used to organize large groups of similar messages together.  Examples of
+	categories include GL errors, performance warnings, and deprecated
+	functionality warnings.  Each message is also assigned a severity level
+	that denotes roughly how "important" that message is in comparison to
+	other messages across all categories.  For example, notification of a GL
+	error would have a higher severity than a performance warning due to
+	redundant state changes.
+	
+	Messages are communicated to the application through an application-defined
+	callback function that is called by the GL implementation on each debug
+	message.  The motivation for the callback routine is to free application
+	developers from actively having to query whether any GL error or other
+	debuggable event has happened after each call to a GL function.  With a
+	callback, developers can keep their code free of debug checks, and only have
+	to react to messages as they occur.  In order to support indirect rendering,
+	a message log is also provided that stores copies of recent messages until
+	they are actively queried.
+	
+	To control the volume of debug output, messages can be disabled either
+	individually by ID, or entire groups of messages can be turned off based
+	on category or severity.
+	
+	The only requirement on the minimum quantity and type of messages that
+	implementations of this extension must support is that a message must be
+	sent notifying the application whenever any GL error occurs.  Any further
+	messages are left to the implementation.  Implementations do not have
+	to output messages from all categories listed by this extension
+	in order to support this extension, and new categories can be added by
+	other extensions.
+	
+	This extension places no restrictions or requirements on any additional
+	functionality provided by the debug context flag through other extensions. 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/debug_output.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.debug_output import *
+from OpenGL.raw.GL.AMD.debug_output import _EXTENSION_NAME
+
+def glInitDebugOutputAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glDebugMessageEnableAMD.ids size not checked against count
+glDebugMessageEnableAMD=wrapper.wrapper(glDebugMessageEnableAMD).setInputArraySize(
+    'ids', None
+)
+# INPUT glDebugMessageInsertAMD.buf size not checked against length
+glDebugMessageInsertAMD=wrapper.wrapper(glDebugMessageInsertAMD).setInputArraySize(
+    'buf', None
+)
+# glDebugMessageCallbackAMD.userParam is OUTPUT without known output size
+glGetDebugMessageLogAMD=wrapper.wrapper(glGetDebugMessageLogAMD).setOutput(
+    'categories',size=lambda x:(x,),pnameArg='count',orPassIn=True
+).setOutput(
+    'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True
+).setOutput(
+    'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True
+).setOutput(
+    'message',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True
+).setOutput(
+    'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True
+)
+### END AUTOGENERATED SECTION

pyopengl-3.1.9/OpenGL/GL/AMD/multi_draw_indirect.py

@@ -0,0 +1,44 @@
+'''OpenGL extension AMD.multi_draw_indirect
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.multi_draw_indirect to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The ARB_draw_indirect extension (included in OpenGL 4.0) introduced
+	mechanisms whereby the parameters for a draw function may be provided in
+	a structure contained in a buffer object rather than as parameters to the
+	drawing procedure. This is known as an indirect draw and is exposed as two
+	new functions, glDrawArraysIndirect and glDrawElementsIndirect. Each of
+	these functions generates a single batch of primitives.
+	
+	This extension builds on this functionality by providing procedures to
+	invoke multiple draws from a single procedure call. This allows large
+	batches of drawing commands to be assembled in server memory (via a buffer
+	object) which may then be dispatched through a single function call.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/multi_draw_indirect.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.multi_draw_indirect import *
+from OpenGL.raw.GL.AMD.multi_draw_indirect import _EXTENSION_NAME
+
+def glInitMultiDrawIndirectAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glMultiDrawArraysIndirectAMD.indirect size not checked against 'primcount,stride'
+glMultiDrawArraysIndirectAMD=wrapper.wrapper(glMultiDrawArraysIndirectAMD).setInputArraySize(
+    'indirect', None
+)
+# INPUT glMultiDrawElementsIndirectAMD.indirect size not checked against 'primcount,stride'
+glMultiDrawElementsIndirectAMD=wrapper.wrapper(glMultiDrawElementsIndirectAMD).setInputArraySize(
+    'indirect', None
+)
+### END AUTOGENERATED SECTION

pyopengl-3.1.9/OpenGL/GL/AMD/performance_monitor.py

@@ -0,0 +1,71 @@
+'''OpenGL extension AMD.performance_monitor
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.performance_monitor to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension enables the capture and reporting of performance monitors.
+	Performance monitors contain groups of counters which hold arbitrary counted 
+	data.  Typically, the counters hold information on performance-related
+	counters in the underlying hardware.  The extension is general enough to
+	allow the implementation to choose which counters to expose and pick the
+	data type and range of the counters.  The extension also allows counting to 
+	start and end on arbitrary boundaries during rendering.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/performance_monitor.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.performance_monitor import *
+from OpenGL.raw.GL.AMD.performance_monitor import _EXTENSION_NAME
+
+def glInitPerformanceMonitorAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glGetPerfMonitorGroupsAMD=wrapper.wrapper(glGetPerfMonitorGroupsAMD).setOutput(
+    'groups',size=lambda x:(x,),pnameArg='groupsSize',orPassIn=True
+).setOutput(
+    'numGroups',size=(1,),orPassIn=True
+)
+glGetPerfMonitorCountersAMD=wrapper.wrapper(glGetPerfMonitorCountersAMD).setOutput(
+    'counters',size=lambda x:(x,),pnameArg='counterSize',orPassIn=True
+).setOutput(
+    'maxActiveCounters',size=(1,),orPassIn=True
+).setOutput(
+    'numCounters',size=(1,),orPassIn=True
+)
+glGetPerfMonitorGroupStringAMD=wrapper.wrapper(glGetPerfMonitorGroupStringAMD).setOutput(
+    'groupString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True
+).setOutput(
+    'length',size=(1,),orPassIn=True
+)
+glGetPerfMonitorCounterStringAMD=wrapper.wrapper(glGetPerfMonitorCounterStringAMD).setOutput(
+    'counterString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True
+).setOutput(
+    'length',size=(1,),orPassIn=True
+)
+glGetPerfMonitorCounterInfoAMD=wrapper.wrapper(glGetPerfMonitorCounterInfoAMD).setOutput(
+    'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGenPerfMonitorsAMD=wrapper.wrapper(glGenPerfMonitorsAMD).setOutput(
+    'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True
+)
+glDeletePerfMonitorsAMD=wrapper.wrapper(glDeletePerfMonitorsAMD).setOutput(
+    'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True
+)
+glSelectPerfMonitorCountersAMD=wrapper.wrapper(glSelectPerfMonitorCountersAMD).setOutput(
+    'counterList',size=lambda x:(x,),pnameArg='numCounters',orPassIn=True
+)
+glGetPerfMonitorCounterDataAMD=wrapper.wrapper(glGetPerfMonitorCounterDataAMD).setOutput(
+    'bytesWritten',size=(1,),orPassIn=True
+).setOutput(
+    'data',size=lambda x: (x//4),pnameArg='dataSize',orPassIn=True
+)
+### END AUTOGENERATED SECTION

pyopengl-3.1.9/OpenGL/GL/APPLE/ycbcr_422.py

@@ -0,0 +1,62 @@
+'''OpenGL extension APPLE.ycbcr_422
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.APPLE.ycbcr_422 to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension provides a method for GL to read, store and optionally
+	process textures that are defined in Y'CbCr 422 video formats.  This
+	extension supports the two common Y'CbCr 422 video formats (known by
+	QuickTime FourCC as '2vuy' and 'yuvs'). These formats represent one of the
+	most common 16 bit Y'CbCr formats in both standard and reverse byte
+	ordering. From a client stand point these can be assumed to be decoded
+	immediately (even though the implementation is free to optimize the data
+	storage and keep it in the native format) and otherwise function as any
+	other texture format.  The texture command <internalformat> parameter
+	normally be should be specified as RGB, since Y'CbCr is just a form of RGB
+	data.  This extension can be supported with either hardware or software
+	decoding and it is up to the specific implementation to determine which is
+	used.
+	
+	A new <format> is added, YCBCR_422_APPLE.  Additionally, to handle the
+	difference in pixel size and byte ordering for 422 video, the pixel storage
+	operations treat YCBCR_422_APPLE as a 2 component format using
+	the UNSIGNED_SHORT_8_8_APPLE or UNSIGNED_SHORT_8_8_REV_APPLE <type>.
+	
+	The '2vuy' or k2vuyPixelFormat pixel format is an 8-bit 4:2:2 Component
+	Y'CbCr format. Each 16 bit pixel is represented by an unsigned eight bit
+	luminance component and two unsigned eight bit chroma components. Each pair
+	of pixels shares a common set of chroma values. The components are ordered
+	in memory; Cb, Y0, Cr, Y1. The luminance components have a range of [16,
+	235], while the chroma value has a range of [16, 240]. This is consistent
+	with the CCIR601 spec. This format is fairly prevalent on both Mac and Win32
+	platforms. The equivalent Microsoft fourCC is 'UYVY'.  This format is
+	supported with the UNSIGNED_SHORT_8_8_REV_APPLE type for pixel storage
+	operations.
+	
+	The 'yuvs' or kYUVSPixelFormat is an 8-bit 4:2:2 Component Y'CbCr format.
+	Identical to the k2vuyPixelFormat except each 16 bit word has been byte
+	swapped. This results in a component ordering of; Y0, Cb, Y1, Cr. This is
+	most prevalent yuv 4:2:2 format on both Mac and Win32 platforms. The
+	equivalent Microsoft fourCC is 'YUY2'.  This format is supported with the
+	UNSIGNED_SHORT_8_8_APPLE type for pixel storage operations.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/APPLE/ycbcr_422.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.APPLE.ycbcr_422 import *
+from OpenGL.raw.GL.APPLE.ycbcr_422 import _EXTENSION_NAME
+
+def glInitYcbcr422APPLE():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION