384 lines
12 KiB
Python
384 lines
12 KiB
Python
from enum import Enum
|
|
|
|
from pyglet import gl
|
|
from pyglet.gl import gl_info
|
|
|
|
|
|
class OpenGLAPI(Enum):
|
|
OPENGL = 1
|
|
OPENGL_ES = 2
|
|
|
|
|
|
class Config:
|
|
"""Graphics configuration.
|
|
|
|
A Config stores the preferences for OpenGL attributes such as the
|
|
number of auxiliary buffers, size of the colour and depth buffers,
|
|
double buffering, stencilling, multi- and super-sampling, and so on.
|
|
|
|
Different platforms support a different set of attributes, so these
|
|
are set with a string key and a value which is integer or boolean.
|
|
|
|
:Ivariables:
|
|
`double_buffer` : bool
|
|
Specify the presence of a back-buffer for every color buffer.
|
|
`stereo` : bool
|
|
Specify the presence of separate left and right buffer sets.
|
|
`buffer_size` : int
|
|
Total bits per sample per color buffer.
|
|
`aux_buffers` : int
|
|
The number of auxiliary color buffers.
|
|
`sample_buffers` : int
|
|
The number of multisample buffers.
|
|
`samples` : int
|
|
The number of samples per pixel, or 0 if there are no multisample
|
|
buffers.
|
|
`red_size` : int
|
|
Bits per sample per buffer devoted to the red component.
|
|
`green_size` : int
|
|
Bits per sample per buffer devoted to the green component.
|
|
`blue_size` : int
|
|
Bits per sample per buffer devoted to the blue component.
|
|
`alpha_size` : int
|
|
Bits per sample per buffer devoted to the alpha component.
|
|
`depth_size` : int
|
|
Bits per sample in the depth buffer.
|
|
`stencil_size` : int
|
|
Bits per sample in the stencil buffer.
|
|
`accum_red_size` : int
|
|
Bits per pixel devoted to the red component in the accumulation
|
|
buffer.
|
|
`accum_green_size` : int
|
|
Bits per pixel devoted to the green component in the accumulation
|
|
buffer.
|
|
`accum_blue_size` : int
|
|
Bits per pixel devoted to the blue component in the accumulation
|
|
buffer.
|
|
`accum_alpha_size` : int
|
|
Bits per pixel devoted to the alpha component in the accumulation
|
|
buffer.
|
|
"""
|
|
|
|
_attribute_names = [
|
|
'double_buffer',
|
|
'stereo',
|
|
'buffer_size',
|
|
'aux_buffers',
|
|
'sample_buffers',
|
|
'samples',
|
|
'red_size',
|
|
'green_size',
|
|
'blue_size',
|
|
'alpha_size',
|
|
'depth_size',
|
|
'stencil_size',
|
|
'accum_red_size',
|
|
'accum_green_size',
|
|
'accum_blue_size',
|
|
'accum_alpha_size',
|
|
'major_version',
|
|
'minor_version',
|
|
'forward_compatible',
|
|
'opengl_api',
|
|
'debug'
|
|
]
|
|
|
|
major_version = None
|
|
minor_version = None
|
|
forward_compatible = None
|
|
opengl_api = None
|
|
debug = None
|
|
|
|
def __init__(self, **kwargs):
|
|
"""Create a template config with the given attributes.
|
|
|
|
Specify attributes as keyword arguments, for example::
|
|
|
|
template = Config(double_buffer=True)
|
|
|
|
"""
|
|
for name in self._attribute_names:
|
|
if name in kwargs:
|
|
setattr(self, name, kwargs[name])
|
|
else:
|
|
setattr(self, name, None)
|
|
|
|
self.opengl_api = self.opengl_api or "gl"
|
|
|
|
def get_gl_attributes(self):
|
|
"""Return a list of attributes set on this config.
|
|
|
|
:rtype: list of tuple (name, value)
|
|
:return: All attributes, with unset attributes having a value of
|
|
``None``.
|
|
"""
|
|
return [(name, getattr(self, name)) for name in self._attribute_names]
|
|
|
|
def match(self, canvas):
|
|
"""Return a list of matching complete configs for the given canvas.
|
|
|
|
.. versionadded:: 1.2
|
|
|
|
:Parameters:
|
|
`canvas` : `Canvas`
|
|
Display to host contexts created from the config.
|
|
|
|
:rtype: list of `CanvasConfig`
|
|
"""
|
|
raise NotImplementedError('abstract')
|
|
|
|
def create_context(self, share):
|
|
"""Create a GL context that satisifies this configuration.
|
|
|
|
:deprecated: Use `CanvasConfig.create_context`.
|
|
|
|
:Parameters:
|
|
`share` : `Context`
|
|
If not None, a context with which to share objects with.
|
|
|
|
:rtype: `Context`
|
|
:return: The new context.
|
|
"""
|
|
raise gl.ConfigException('This config cannot be used to create contexts. '
|
|
'Use Config.match to created a CanvasConfig')
|
|
|
|
def is_complete(self):
|
|
"""Determine if this config is complete and able to create a context.
|
|
|
|
Configs created directly are not complete, they can only serve
|
|
as templates for retrieving a supported config from the system.
|
|
For example, `pyglet.window.Screen.get_matching_configs` returns
|
|
complete configs.
|
|
|
|
:deprecated: Use ``isinstance(config, CanvasConfig)``.
|
|
|
|
:rtype: bool
|
|
:return: True if the config is complete and can create a context.
|
|
"""
|
|
return isinstance(self, CanvasConfig)
|
|
|
|
def __repr__(self):
|
|
return f"{self.__class__.__name__}({self.get_gl_attributes()})"
|
|
|
|
|
|
class CanvasConfig(Config):
|
|
"""OpenGL configuration for a particular canvas.
|
|
|
|
Use `Config.match` to obtain an instance of this class.
|
|
|
|
.. versionadded:: 1.2
|
|
|
|
:Ivariables:
|
|
`canvas` : `Canvas`
|
|
The canvas this config is valid on.
|
|
|
|
"""
|
|
|
|
def __init__(self, canvas, base_config):
|
|
self.canvas = canvas
|
|
|
|
self.major_version = base_config.major_version
|
|
self.minor_version = base_config.minor_version
|
|
self.forward_compatible = base_config.forward_compatible
|
|
self.opengl_api = base_config.opengl_api or self.opengl_api
|
|
self.debug = base_config.debug
|
|
|
|
def compatible(self, canvas):
|
|
raise NotImplementedError('abstract')
|
|
|
|
def create_context(self, share):
|
|
"""Create a GL context that satisifies this configuration.
|
|
|
|
:Parameters:
|
|
`share` : `Context`
|
|
If not None, a context with which to share objects with.
|
|
|
|
:rtype: `Context`
|
|
:return: The new context.
|
|
"""
|
|
raise NotImplementedError('abstract')
|
|
|
|
def is_complete(self):
|
|
return True
|
|
|
|
|
|
class ObjectSpace:
|
|
def __init__(self):
|
|
# Textures and buffers scheduled for deletion
|
|
# the next time this object space is active.
|
|
self.doomed_textures = []
|
|
self.doomed_buffers = []
|
|
self.doomed_vaos = []
|
|
self.doomed_shader_programs = []
|
|
|
|
|
|
class Context:
|
|
"""OpenGL context for drawing.
|
|
|
|
Use `CanvasConfig.create_context` to create a context.
|
|
|
|
:Ivariables:
|
|
`object_space` : `ObjectSpace`
|
|
An object which is shared between all contexts that share
|
|
GL objects.
|
|
|
|
"""
|
|
# gl_info.GLInfo instance, filled in on first set_current
|
|
_info = None
|
|
|
|
def __init__(self, config, context_share=None):
|
|
self.config = config
|
|
self.context_share = context_share
|
|
self.canvas = None
|
|
|
|
if context_share:
|
|
self.object_space = context_share.object_space
|
|
else:
|
|
self.object_space = ObjectSpace()
|
|
|
|
def __repr__(self):
|
|
return f"{self.__class__.__name__}(id={id(self)}, share={self.context_share})"
|
|
|
|
def attach(self, canvas):
|
|
if self.canvas is not None:
|
|
self.detach()
|
|
if not self.config.compatible(canvas):
|
|
raise RuntimeError(f'Cannot attach {canvas} to {self}')
|
|
self.canvas = canvas
|
|
|
|
def detach(self):
|
|
self.canvas = None
|
|
|
|
def set_current(self):
|
|
if not self.canvas:
|
|
raise RuntimeError('Canvas has not been attached')
|
|
|
|
# XXX not per-thread
|
|
gl.current_context = self
|
|
|
|
# XXX
|
|
gl_info.set_active_context()
|
|
|
|
if not self._info:
|
|
self._info = gl_info.GLInfo()
|
|
self._info.set_active_context()
|
|
|
|
# Release Textures, Buffers, and VAOs on this context scheduled for
|
|
# deletion. Note that the garbage collector may introduce a race
|
|
# condition, so operate on a copy, and clear the list afterwards.
|
|
if self.object_space.doomed_textures:
|
|
textures = self.object_space.doomed_textures[:]
|
|
textures = (gl.GLuint * len(textures))(*textures)
|
|
gl.glDeleteTextures(len(textures), textures)
|
|
self.object_space.doomed_textures.clear()
|
|
if self.object_space.doomed_buffers:
|
|
buffers = self.object_space.doomed_buffers[:]
|
|
buffers = (gl.GLuint * len(buffers))(*buffers)
|
|
gl.glDeleteBuffers(len(buffers), buffers)
|
|
self.object_space.doomed_buffers.clear()
|
|
if self.object_space.doomed_vaos:
|
|
vaos = self.object_space.doomed_vaos[:]
|
|
vaos = (gl.GLuint * len(vaos))(*vaos)
|
|
gl.glDeleteVertexArrays(len(vaos), vaos)
|
|
self.object_space.doomed_vaos.clear()
|
|
if self.object_space.doomed_shader_programs:
|
|
for program_id in self.object_space.doomed_shader_programs:
|
|
gl.glDeleteProgram(program_id)
|
|
self.object_space.doomed_shader_programs.clear()
|
|
|
|
def destroy(self):
|
|
"""Release the context.
|
|
|
|
The context will not be useable after being destroyed. Each platform
|
|
has its own convention for releasing the context and the buffer(s)
|
|
that depend on it in the correct order; this should never be called
|
|
by an application.
|
|
"""
|
|
self.detach()
|
|
|
|
if gl.current_context is self:
|
|
gl.current_context = None
|
|
gl_info.remove_active_context()
|
|
|
|
# Switch back to shadow context.
|
|
if gl._shadow_window is not None:
|
|
gl._shadow_window.switch_to()
|
|
|
|
def delete_texture(self, texture_id):
|
|
"""Safely delete a Texture belonging to this context.
|
|
|
|
Usually, the Texture is released immediately using
|
|
``glDeleteTextures``, however if another context that does not share
|
|
this context's object space is currently active, the deletion will
|
|
be deferred until an appropriate context is activated.
|
|
|
|
:Parameters:
|
|
`texture_id` : int
|
|
The OpenGL name of the Texture to delete.
|
|
|
|
"""
|
|
if self.object_space is gl.current_context.object_space:
|
|
gl.glDeleteTextures(1, gl.GLuint(texture_id))
|
|
else:
|
|
self.object_space.doomed_textures.append(texture_id)
|
|
|
|
def delete_buffer(self, buffer_id):
|
|
"""Safely delete a Buffer object belonging to this context.
|
|
|
|
This method behaves similarly to `delete_texture`, though for
|
|
``glDeleteBuffers`` instead of ``glDeleteTextures``.
|
|
|
|
:Parameters:
|
|
`buffer_id` : int
|
|
The OpenGL name of the buffer to delete.
|
|
|
|
.. versionadded:: 1.1
|
|
"""
|
|
if self.object_space is gl.current_context.object_space and False:
|
|
gl.glDeleteBuffers(1, gl.GLuint(buffer_id))
|
|
else:
|
|
self.object_space.doomed_buffers.append(buffer_id)
|
|
|
|
def delete_vao(self, vao_id):
|
|
"""Safely delete a Vertex Array Object belonging to this context.
|
|
|
|
This method behaves similarly to `delete_texture`, though for
|
|
``glDeleteVertexArrays`` instead of ``glDeleteTextures``.
|
|
|
|
:Parameters:
|
|
`vao_id` : int
|
|
The OpenGL name of the Vertex Array to delete.
|
|
|
|
.. versionadded:: 2.0
|
|
"""
|
|
if gl.current_context and self.object_space is gl.current_context.object_space and False:
|
|
gl.glDeleteVertexArrays(1, gl.GLuint(vao_id))
|
|
else:
|
|
self.object_space.doomed_vaos.append(vao_id)
|
|
|
|
def delete_shader_program(self, program_id):
|
|
"""Safely delete a Shader Program belonging to this context.
|
|
|
|
This method behaves similarly to `delete_texture`, though for
|
|
``glDeleteProgram`` instead of ``glDeleteTextures``.
|
|
|
|
:Parameters:
|
|
`program_id` : int
|
|
The OpenGL name of the Shader Program to delete.
|
|
|
|
.. versionadded:: 2.0
|
|
"""
|
|
if gl.current_context is self:
|
|
gl.glDeleteProgram(program_id)
|
|
else:
|
|
self.object_space.doomed_shader_programs.append(program_id)
|
|
|
|
def get_info(self):
|
|
"""Get the OpenGL information for this context.
|
|
|
|
.. versionadded:: 1.2
|
|
|
|
:rtype: `GLInfo`
|
|
"""
|
|
return self._info
|