Spaces:
Runtime error
Runtime error
File size: 10,253 Bytes
d82cf6a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 |
"""Byte abstractions of OpenGL Buffer Objects.
Use `create_buffer` to create a Buffer Object.
Buffers can optionally be created "mappable" (incorporating the
`AbstractMappable` mix-in). In this case the buffer provides a ``get_region``
method which provides the most efficient path for updating partial data within
the buffer.
"""
import sys
import ctypes
import pyglet
from pyglet.gl import *
class AbstractBuffer:
"""Abstract buffer of byte data.
:Ivariables:
`size` : int
Size of buffer, in bytes
`ptr` : int
Memory offset of the buffer, as used by the ``glVertexPointer``
family of functions
`usage` : int
OpenGL buffer usage, for example ``GL_DYNAMIC_DRAW``
"""
ptr = 0
size = 0
def bind(self, target=GL_ARRAY_BUFFER):
"""Bind this buffer to an OpenGL target."""
raise NotImplementedError('abstract')
def unbind(self):
"""Reset the buffer's OpenGL target."""
raise NotImplementedError('abstract')
def set_data(self, data):
"""Set the entire contents of the buffer.
:Parameters:
`data` : sequence of int or ctypes pointer
The byte array to set.
"""
raise NotImplementedError('abstract')
def set_data_region(self, data, start, length):
"""Set part of the buffer contents.
:Parameters:
`data` : sequence of int or ctypes pointer
The byte array of data to set
`start` : int
Offset to start replacing data
`length` : int
Length of region to replace
"""
raise NotImplementedError('abstract')
def map(self):
"""Map the entire buffer into system memory.
The mapped region must be subsequently unmapped with `unmap` before
performing any other operations on the buffer.
:Parameters:
`invalidate` : bool
If True, the initial contents of the mapped block need not
reflect the actual contents of the buffer.
:rtype: ``POINTER(ctypes.c_ubyte)``
:return: Pointer to the mapped block in memory
"""
raise NotImplementedError('abstract')
def unmap(self):
"""Unmap a previously mapped memory block."""
raise NotImplementedError('abstract')
def resize(self, size):
"""Resize the buffer to a new size.
:Parameters:
`size` : int
New size of the buffer, in bytes
"""
def delete(self):
"""Delete this buffer, reducing system resource usage."""
raise NotImplementedError('abstract')
class AbstractMappable:
def get_region(self, start, size, ptr_type):
"""Map a region of the buffer into a ctypes array of the desired
type. This region does not need to be unmapped, but will become
invalid if the buffer is resized.
Note that although a pointer type is required, an array is mapped.
For example::
get_region(0, ctypes.sizeof(c_int) * 20, ctypes.POINTER(c_int * 20))
will map bytes 0 to 80 of the buffer to an array of 20 ints.
Changes to the array may not be recognised until the region's
:py:meth:`AbstractBufferRegion.invalidate` method is called.
:Parameters:
`start` : int
Offset into the buffer to map from, in bytes
`size` : int
Size of the buffer region to map, in bytes
`ptr_type` : ctypes pointer type
Pointer type describing the array format to create
:rtype: :py:class:`AbstractBufferRegion`
"""
raise NotImplementedError('abstract')
class BufferObject(AbstractBuffer):
"""Lightweight representation of an OpenGL Buffer Object.
The data in the buffer is not replicated in any system memory (unless it
is done so by the video driver). While this can improve memory usage and
possibly performance, updates to the buffer are relatively slow.
The target of the buffer is ``GL_ARRAY_BUFFER`` internally to avoid
accidentally overriding other states when altering the buffer contents.
The intended target can be set when binding the buffer.
This class does not implement :py:class:`AbstractMappable`, and so has no
:py:meth:`~AbstractMappable.get_region` method. See
:py:class:`MappableVertexBufferObject` for a Buffer class
that does implement :py:meth:`~AbstractMappable.get_region`.
"""
def __init__(self, size, usage=GL_DYNAMIC_DRAW):
self.size = size
self.usage = usage
self._context = pyglet.gl.current_context
buffer_id = GLuint()
glGenBuffers(1, buffer_id)
self.id = buffer_id.value
glBindBuffer(GL_ARRAY_BUFFER, self.id)
data = (GLubyte * self.size)()
glBufferData(GL_ARRAY_BUFFER, self.size, data, self.usage)
def invalidate(self):
glBufferData(GL_ARRAY_BUFFER, self.size, None, self.usage)
def bind(self, target=GL_ARRAY_BUFFER):
glBindBuffer(target, self.id)
def unbind(self):
glBindBuffer(GL_ARRAY_BUFFER, 0)
def bind_to_index_buffer(self):
"""Binds this buffer as an index buffer on the active vertex array."""
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self.id)
def set_data(self, data):
glBindBuffer(GL_ARRAY_BUFFER, self.id)
glBufferData(GL_ARRAY_BUFFER, self.size, data, self.usage)
def set_data_region(self, data, start, length):
glBindBuffer(GL_ARRAY_BUFFER, self.id)
glBufferSubData(GL_ARRAY_BUFFER, start, length, data)
def map(self):
glBindBuffer(GL_ARRAY_BUFFER, self.id)
ptr = ctypes.cast(glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY), ctypes.POINTER(ctypes.c_byte * self.size)).contents
return ptr
def map_range(self, start, size, ptr_type):
glBindBuffer(GL_ARRAY_BUFFER, self.id)
ptr = ctypes.cast(glMapBufferRange(GL_ARRAY_BUFFER, start, size, GL_MAP_WRITE_BIT), ptr_type).contents
return ptr
def unmap(self):
glUnmapBuffer(GL_ARRAY_BUFFER)
def __del__(self):
try:
if self.id is not None:
self._context.delete_buffer(self.id)
except:
pass
def delete(self):
buffer_id = GLuint(self.id)
try:
glDeleteBuffers(1, buffer_id)
except Exception:
pass
self.id = None
def resize(self, size):
# Map, create a copy, then reinitialize.
temp = (ctypes.c_byte * size)()
glBindBuffer(GL_ARRAY_BUFFER, self.id)
data = glMapBufferRange(GL_ARRAY_BUFFER, 0, self.size, GL_MAP_READ_BIT)
ctypes.memmove(temp, data, min(size, self.size))
glUnmapBuffer(GL_ARRAY_BUFFER)
self.size = size
glBufferData(GL_ARRAY_BUFFER, self.size, temp, self.usage)
def __repr__(self):
return f"{self.__class__.__name__}(id={self.id}, size={self.size})"
class MappableBufferObject(BufferObject, AbstractMappable):
"""A buffer with system-memory backed store.
Updates to the data via `set_data`, `set_data_region` and `map` will be
held in local memory until `bind` is called. The advantage is that fewer
OpenGL calls are needed, increasing performance.
There may also be less performance penalty for resizing this buffer.
Updates to data via :py:meth:`map` are committed immediately.
"""
def __init__(self, size, usage=GL_DYNAMIC_DRAW):
super(MappableBufferObject, self).__init__(size, usage)
self.data = (ctypes.c_byte * size)()
self.data_ptr = ctypes.addressof(self.data)
self._dirty_min = sys.maxsize
self._dirty_max = 0
def bind(self):
# Commit pending data
super(MappableBufferObject, self).bind()
size = self._dirty_max - self._dirty_min
if size > 0:
if size == self.size:
glBufferData(GL_ARRAY_BUFFER, self.size, self.data, self.usage)
else:
glBufferSubData(GL_ARRAY_BUFFER, self._dirty_min, size, self.data_ptr + self._dirty_min)
self._dirty_min = sys.maxsize
self._dirty_max = 0
def set_data(self, data):
super(MappableBufferObject, self).set_data(data)
ctypes.memmove(self.data, data, self.size)
self._dirty_min = 0
self._dirty_max = self.size
def set_data_region(self, data, start, length):
ctypes.memmove(self.data_ptr + start, data, length)
self._dirty_min = min(start, self._dirty_min)
self._dirty_max = max(start + length, self._dirty_max)
def map(self, invalidate=False):
self._dirty_min = 0
self._dirty_max = self.size
return self.data
def unmap(self):
pass
def get_region(self, start, size, ptr_type):
array = ctypes.cast(self.data_ptr + start, ptr_type).contents
return BufferObjectRegion(self, start, start + size, array)
def resize(self, size):
data = (ctypes.c_byte * size)()
ctypes.memmove(data, self.data, min(size, self.size))
self.data = data
self.data_ptr = ctypes.addressof(self.data)
self.size = size
glBindBuffer(GL_ARRAY_BUFFER, self.id)
glBufferData(GL_ARRAY_BUFFER, self.size, self.data, self.usage)
self._dirty_min = sys.maxsize
self._dirty_max = 0
class BufferObjectRegion:
"""A mapped region of a MappableBufferObject."""
__slots__ = 'buffer', 'start', 'end', 'array'
def __init__(self, buffer, start, end, array):
self.buffer = buffer
self.start = start
self.end = end
self.array = array
def invalidate(self):
"""Mark this region as changed.
The buffer may not be updated with the latest contents of the
array until this method is called. (However, it may not be updated
until the next time the buffer is used, for efficiency).
"""
buffer = self.buffer
buffer._dirty_min = min(buffer._dirty_min, self.start)
buffer._dirty_max = max(buffer._dirty_max, self.end)
|