# -*- coding: utf-8 -*- # ----------------------------------------------------------------------------- # Copyright (c) Vispy Development Team. All Rights Reserved. # Distributed under the (new) BSD License. See LICENSE.txt for more info. # ----------------------------------------------------------------------------- from .globject import GLObject from .texture import Texture2D from .wrappers import _check_valid, read_pixels from .context import get_current_canvas # ------------------------------------------------------ RenderBuffer class --- class RenderBuffer(GLObject): """Base class for render buffer object A render buffer can be in color, depth or stencil format. If this format is not specified, it is set when attached to the FrameBuffer. Parameters ---------- shape : tuple The shape of the render buffer. format : {None, 'color', 'depth', 'stencil'} The format of the render buffer. See resize. resizeable : bool Indicates whether texture can be resized """ _GLIR_TYPE = 'RenderBuffer' def __init__(self, shape=None, format=None, resizeable=True): GLObject.__init__(self) self._format = None self._resizeable = True self.resize(shape, format) self._resizeable = bool(resizeable) @property def shape(self): """Render Buffer shape""" return self._shape @property def format(self): """Render Buffer format""" return self._format def resize(self, shape, format=None): """Set the render-buffer size and format Parameters ---------- shape : tuple of integers New shape in yx order. A render buffer is always 2D. For symmetry with the texture class, a 3-element tuple can also be given, in which case the last dimension is ignored. format : {None, 'color', 'depth', 'stencil'} The buffer format. If None, the current format is maintained. If that is also None, the format will be set upon attaching it to a framebuffer. One can also specify the explicit enum: GL_RGB565, GL_RGBA4, GL_RGB5_A1, GL_DEPTH_COMPONENT16, or GL_STENCIL_INDEX8 """ if not self._resizeable: raise RuntimeError("RenderBuffer is not resizeable") # Check shape if not (isinstance(shape, tuple) and len(shape) in (2, 3)): raise ValueError('RenderBuffer shape must be a 2/3 element tuple') # Check format if format is None: format = self._format # Use current format (may be None) elif isinstance(format, int): pass # Do not check, maybe user needs desktop GL formats elif isinstance(format, str): if format not in ('color', 'depth', 'stencil'): raise ValueError('RenderBuffer format must be "color", "depth"' ' or "stencil", not %r' % format) else: raise ValueError('Invalid RenderBuffer format: %r' % format) # Store and send GLIR command self._shape = tuple(shape[:2]) self._format = format if self._format is not None: self._glir.command('SIZE', self._id, self._shape, self._format) # ------------------------------------------------------- FrameBuffer class --- class FrameBuffer(GLObject): """Frame buffer object Parameters ---------- color : RenderBuffer (optional) The color buffer to attach to this frame buffer depth : RenderBuffer (optional) The depth buffer to attach to this frame buffer stencil : RenderBuffer (optional) The stencil buffer to attach to this frame buffer """ _GLIR_TYPE = 'FrameBuffer' def __init__(self, color=None, depth=None, stencil=None): GLObject.__init__(self) # Init buffers self._color_buffer = None self._depth_buffer = None self._stencil_buffer = None if color is not None: self.color_buffer = color if depth is not None: self.depth_buffer = depth if stencil is not None: self.stencil_buffer = stencil def activate(self): """Activate/use this frame buffer.""" # Send command self._glir.command('FRAMEBUFFER', self._id, True) # Associate canvas now canvas = get_current_canvas() if canvas is not None: canvas.context.glir.associate(self.glir) def deactivate(self): """Stop using this frame buffer, the previous framebuffer will be made active. """ self._glir.command('FRAMEBUFFER', self._id, False) def __enter__(self): self.activate() return self def __exit__(self, t, val, trace): self.deactivate() def _set_buffer(self, buffer, format): formats = ('color', 'depth', 'stencil') assert format in formats # Auto-format or check render buffer if isinstance(buffer, RenderBuffer): if buffer.format is None: buffer.resize(buffer.shape, format) elif buffer.format in formats and buffer.format != format: raise ValueError('Cannot attach a %s buffer as %s buffer.' % (buffer.format, format)) # Attach if buffer is None: setattr(self, '_%s_buffer' % format, None) self._glir.command('ATTACH', self._id, format, 0) elif isinstance(buffer, (Texture2D, RenderBuffer)): self.glir.associate(buffer.glir) setattr(self, '_%s_buffer' % format, buffer) self._glir.command('ATTACH', self._id, format, buffer.id) else: raise TypeError("Buffer must be a RenderBuffer, Texture2D or None." " (got %s)" % type(buffer)) @property def color_buffer(self): """Color buffer attachment""" return self._color_buffer @color_buffer.setter def color_buffer(self, buffer): self._set_buffer(buffer, 'color') @property def depth_buffer(self): """Depth buffer attachment""" return self._depth_buffer @depth_buffer.setter def depth_buffer(self, buffer): self._set_buffer(buffer, 'depth') @property def stencil_buffer(self): """Stencil buffer attachment""" return self._stencil_buffer @stencil_buffer.setter def stencil_buffer(self, buffer): self._set_buffer(buffer, 'stencil') @property def shape(self): """The shape of the Texture/RenderBuffer attached to this FrameBuffer""" if self.color_buffer is not None: return self.color_buffer.shape[:2] # in case its a texture if self.depth_buffer is not None: return self.depth_buffer.shape[:2] if self.stencil_buffer is not None: return self.stencil_buffer.shape[:2] raise RuntimeError('FrameBuffer without buffers has undefined shape') def resize(self, shape): """Resize all attached buffers with the given shape Parameters ---------- shape : tuple of two integers New buffer shape (h, w), to be applied to all currently attached buffers. For buffers that are a texture, the number of color channels is preserved. """ # Check if not (isinstance(shape, tuple) and len(shape) == 2): raise ValueError('RenderBuffer shape must be a 2-element tuple') # Resize our buffers for buf in (self.color_buffer, self.depth_buffer, self.stencil_buffer): if buf is None: continue shape_ = shape if isinstance(buf, Texture2D): shape_ = shape + (buf._inv_formats[buf.format], ) buf.resize(shape_, buf.format) def read(self, mode='color', alpha=True, crop=None): """Return array of pixel values in an attached buffer Parameters ---------- mode : str The buffer type to read. May be 'color', 'depth', or 'stencil'. alpha : bool If True, returns RGBA array. Otherwise, returns RGB. crop : array-like If not None, specifies pixels to read from buffer. Format is (x, y, w, h). Returns ------- buffer : array 3D array of pixels in np.uint8 format. The array shape is (h, w, 3) or (h, w, 4), with the top-left corner of the framebuffer at index [0, 0] in the returned array if crop was not specified. If crop was given, the result will match the offset and dimensions of the crop. """ _check_valid('mode', mode, ['color', 'depth', 'stencil']) buffer = getattr(self, mode + '_buffer') if buffer is None: raise ValueError("Can't read pixels for buffer {}, " "buffer does not exist.".format(mode)) if crop is None: h, w = buffer.shape[:2] crop = (0, 0, w, h) # todo: this is ostensibly required, but not available in gloo.gl # gl.glReadBuffer(buffer._target) return read_pixels(crop, alpha=alpha, mode=mode)