32#define PYGPU_BUFFER_PROTOCOL
33#define MAX_DIMENSIONS 64
41 Py_ssize_t tot = shape[0];
42 for (
int i = 1; i < shape_len; i++) {
50 const Py_ssize_t shape_a_len,
51 const Py_ssize_t *shape_b,
52 const Py_ssize_t shape_b_len)
57 PyErr_SetString(PyExc_BufferError,
"array size does not match");
66 Py_ssize_t *r_shape_len)
68 Py_ssize_t shape_len = 0;
69 if (PyLong_Check(shape_obj)) {
71 if ((r_shape[0] = PyLong_AsSsize_t(shape_obj)) < 1) {
72 PyErr_SetString(PyExc_AttributeError,
"dimension must be greater than or equal to 1");
76 else if (PySequence_Check(shape_obj)) {
77 shape_len = PySequence_Size(shape_obj);
79 PyErr_SetString(PyExc_AttributeError,
84 PyErr_SetString(PyExc_AttributeError,
"sequence must have at least one dimension");
88 for (
int i = 0; i < shape_len; i++) {
89 PyObject *ob = PySequence_GetItem(shape_obj, i);
90 if (!PyLong_Check(ob)) {
91 PyErr_Format(PyExc_TypeError,
92 "invalid dimension %i, expected an int, not a %.200s",
94 Py_TYPE(ob)->tp_name);
99 r_shape[i] = PyLong_AsSsize_t(ob);
102 if (r_shape[i] < 1) {
103 PyErr_SetString(PyExc_AttributeError,
"dimension must be greater than or equal to 1");
109 PyErr_Format(PyExc_TypeError,
110 "invalid second argument expected a sequence "
111 "or an int, not a %.200s",
112 Py_TYPE(shape_obj)->tp_name);
115 *r_shape_len = shape_len;
121 switch (data_format) {
148 const Py_ssize_t *shape,
157 memcpy(buffer->
shape, shape,
sizeof(*buffer->
shape) *
size_t(shape_len));
158 buffer->
buf.as_void = buf;
163 BLI_assert(!PyObject_GC_IsTracked((PyObject *)buffer));
164 PyObject_GC_Track(buffer);
171 if (i >= self->
shape[0] || i < 0) {
172 PyErr_SetString(PyExc_IndexError,
"array index out of range");
181 return Py_BuildValue(formatstr, self->
buf.as_float[i]);
183 return Py_BuildValue(formatstr, self->
buf.as_int[i]);
185 return Py_BuildValue(formatstr, self->
buf.as_byte[i]);
189 return Py_BuildValue(formatstr, self->
buf.as_uint[i]);
194 for (
int j = 1; j < self->
shape_len; j++) {
195 offset *= self->
shape[j];
198 return reinterpret_cast<PyObject *
>(
203 self->
buf.as_byte + offset));
211 const Py_ssize_t
len = self->
shape[0];
212 PyObject *
list = PyList_New(
len);
214 for (Py_ssize_t i = 0; i <
len; i++) {
223 pygpu_buffer_to_list_doc,
224 ".. method:: to_list()\n"
226 " Return the buffer as a list.\n"
228 " :return: The buffer as a list.\n"
238 for (i = 0; i <
len; i++) {
256 pygpu_buffer_dimensions_doc,
257 "The size of the buffer for each dimension.\n"
259 "Setting the dimensions is supported when the total number of elements is unchanged.\n"
261 ":type: list[int]\n");
268 PyList_SET_ITEM(
list, i, PyLong_FromLong(self->
shape[i]));
277 Py_ssize_t shape_len = 0;
288 MEM_delete(self->
shape);
293 memcpy(self->
shape, shape,
sizeof(*self->
shape) *
size_t(shape_len));
307 self->
buf.as_void =
nullptr;
315 PyObject_GC_UnTrack(self);
318 else if (self->
buf.as_void) {
322 MEM_delete(self->
shape);
324 PyObject_GC_Del(self);
334 repr = PyUnicode_FromFormat(
"Buffer(%s, %R)", typestr,
list);
351 end = std::min(end, self->
shape[0]);
354 if (!PySequence_Check(
seq)) {
355 PyErr_Format(PyExc_TypeError,
356 "buffer[:] = value, invalid assignment. "
357 "Expected a sequence, not an %.200s type",
358 Py_TYPE(
seq)->tp_name);
363 if ((count = PySequence_Size(
seq)) != (end -
begin)) {
364 PyErr_Format(PyExc_TypeError,
365 "buffer[:] = value, size mismatch in assignment. "
366 "Expected: %d (given: %d)",
372 for (count =
begin; count < end; count++) {
373 item = PySequence_GetItem(
seq, count -
begin);
392 PyObject *length_ob, *
init =
nullptr;
396 Py_ssize_t shape_len = 0;
398 if (kwds && PyDict_Size(kwds)) {
399 PyErr_SetString(PyExc_TypeError,
"Buffer(): takes no keyword args");
404 if (!PyArg_ParseTuple(args,
418 PyErr_WarnEx(PyExc_DeprecationWarning,
"`UINT_24_8` is deprecated, use `FLOAT` instead", 1);
425 if (
init && PyObject_CheckBuffer(
init)) {
428 if (PyObject_GetBuffer(
init, &pybuffer, PyBUF_ND | PyBUF_FORMAT) == -1) {
433 Py_ssize_t *pybuffer_shape = pybuffer.shape;
434 Py_ssize_t pybuffer_ndim = pybuffer.ndim;
435 if (!pybuffer_shape) {
436 pybuffer_shape = &pybuffer.len;
445 PyBuffer_Release(&pybuffer);
455 return reinterpret_cast<PyObject *
>(buffer);
460 return self->
parent !=
nullptr;
467 return self->
shape[0];
476 end = std::min(end, self->
shape[0]);
481 for (count =
begin; count < end; count++) {
489 if (i >= self->
shape[0] || i < 0) {
490 PyErr_SetString(PyExc_IndexError,
"array assignment index out of range");
508 return PyArg_Parse(
v,
511 &self->
buf.as_float[i]) ?
515 return PyArg_Parse(
v,
518 &self->
buf.as_int[i]) ?
522 return PyArg_Parse(
v,
525 &self->
buf.as_byte[i]) ?
531 return PyArg_Parse(
v,
533 ":Expected unsigned ints",
534 &self->
buf.as_uint[i]) ?
544 if (PyIndex_Check(item)) {
546 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
547 if (i == -1 && PyErr_Occurred()) {
555 if (PySlice_Check(item)) {
556 Py_ssize_t start, stop,
step, slicelength;
558 if (PySlice_GetIndicesEx(item, self->
shape[0], &start, &stop, &
step, &slicelength) < 0) {
562 if (slicelength <= 0) {
563 return PyTuple_New(0);
569 PyErr_SetString(PyExc_IndexError,
"slice steps not supported with vectors");
574 PyExc_TypeError,
"buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
580 if (PyIndex_Check(item)) {
581 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
582 if (i == -1 && PyErr_Occurred()) {
590 if (PySlice_Check(item)) {
591 Py_ssize_t start, stop,
step, slicelength;
593 if (PySlice_GetIndicesEx(item, self->
shape[0], &start, &stop, &
step, &slicelength) < 0) {
601 PyErr_SetString(PyExc_IndexError,
"slice steps not supported with vectors");
606 PyExc_TypeError,
"buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
612# pragma clang diagnostic push
613# pragma clang diagnostic ignored "-Wcast-function-type"
615# pragma GCC diagnostic push
616# pragma GCC diagnostic ignored "-Wcast-function-type"
624 pygpu_buffer_to_list_doc},
625 {
nullptr,
nullptr, 0,
nullptr},
630# pragma clang diagnostic pop
632# pragma GCC diagnostic pop
640 pygpu_buffer_dimensions_doc,
642 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr},
664#ifdef PYGPU_BUFFER_PROTOCOL
667 const Py_ssize_t *shape,
668 Py_ssize_t *r_strides)
671 for (
int i = shape_len; i-- > 0;) {
672 r_strides[i] = stride;
680 if (view ==
nullptr) [[unlikely]] {
681 PyErr_SetString(PyExc_ValueError,
"null view in get-buffer is obsolete");
685 memset(view, 0,
sizeof(*view));
687 view->obj =
reinterpret_cast<PyObject *
>(self);
688 view->buf = self->
buf.as_void;
692 if (flags & PyBUF_FORMAT) {
695 if (flags & PyBUF_ND) {
697 view->shape = self->
shape;
699 if (flags & PyBUF_STRIDES) {
701 "BPyGPUBuffer strides");
705 view->suboffsets =
nullptr;
706 view->internal =
nullptr;
714 MEM_SAFE_DELETE(view->strides);
725 pygpu_buffer__tp_doc,
726 ".. class:: Buffer\n"
728 " For Python access to GPU functions requiring a pointer.\n"
730 " .. method:: __init__(format, dimensions, data)\n"
732 " :param format: Format type to interpret the buffer.\n"
733 " ``UINT_24_8`` is deprecated, use ``FLOAT`` instead.\n"
736 " :param dimensions: Array describing the dimensions.\n"
737 " :type dimensions: int | Sequence[int]\n"
738 " :param data: Optional data array.\n"
739 " :type data: Buffer | Sequence[float] | Sequence[int]\n");
741 PyVarObject_HEAD_INIT(
nullptr, 0)
764 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
765 pygpu_buffer__tp_doc,
798 const Py_ssize_t *shape)
810 const Py_ssize_t *shape,
814 if (buffer ==
nullptr) {
Read Blender memory allocation and freeing.
#define BPYGPU_IS_INIT_OR_ERROR_OBJ
#define PYDOC_DATAFORMAT_LITERAL
#define PYGPU_BUFFER_PROTOCOL
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
PyTypeObject BPyGPU_BufferType
PyC_StringEnumItems bpygpu_dataformat_items[]
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static PyObject * pygpu_buffer_to_list_recursive(BPyGPUBuffer *self)
static bool pygpu_buffer_dimensions_tot_len_compare(const Py_ssize_t *shape_a, const Py_ssize_t shape_a_len, const Py_ssize_t *shape_b, const Py_ssize_t shape_b_len)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static void pygpu_buffer__bf_releasebuffer(PyObject *, Py_buffer *view)
static int pygpu_buffer__tp_clear(BPyGPUBuffer *self)
@ GPU_DATA_UINT_24_8_DEPRECATED
PyDoc_STRVAR(bpy_bm_new_doc, ".. function:: new(*, use_operators=True)\n" "\n" " :param use_operators: Support calling operators in :mod:`bmesh.ops` (uses some " "extra memory per vert/edge/face).\n" " :type use_operators: bool\n" " :return: Return a new, empty BMesh.\n" " :rtype: :class:`bmesh.types.BMesh`\n")
static int pygpu_buffer__mp_ass_subscript(BPyGPUBuffer *self, PyObject *item, PyObject *value)
static BPyGPUBuffer * pygpu_buffer_make_from_data(PyObject *parent, const eGPUDataFormat format, const int shape_len, const Py_ssize_t *shape, void *buf)
ATTR_WARN_UNUSED_RESULT const BMVert * v
static PyBufferProcs pygpu_buffer__tp_as_buffer
static Py_ssize_t pygpu_buffer_dimensions_tot_elem(const Py_ssize_t *shape, Py_ssize_t shape_len)
static void pygpu_buffer__tp_dealloc(BPyGPUBuffer *self)
void MEM_delete_void(void *vmemh)
static PyObject * pygpu_buffer__mp_subscript(BPyGPUBuffer *self, PyObject *item)
static PyObject * pygpu_buffer__tp_repr(BPyGPUBuffer *self)
static PyObject * pygpu_buffer_slice(BPyGPUBuffer *self, Py_ssize_t begin, Py_ssize_t end)
static size_t pygpu_buffer_calc_size(const int format, const int shape_len, const Py_ssize_t *shape)
static PyGetSetDef pygpu_buffer_getseters[]
static int pygpu_buffer__tp_traverse(BPyGPUBuffer *self, visitproc visit, void *arg)
static int pygpu_buffer__bf_getbuffer(BPyGPUBuffer *self, Py_buffer *view, int flags)
static PyMethodDef pygpu_buffer__tp_methods[]
static int pygpu_buffer__sq_ass_item(BPyGPUBuffer *self, Py_ssize_t i, PyObject *v)
size_t bpygpu_Buffer_size(BPyGPUBuffer *buffer)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
size_t GPU_texture_dataformat_size(eGPUDataFormat data_format)
static PyObject * pygpu_buffer_dimensions_get(BPyGPUBuffer *self, void *)
static const char * pygpu_buffer_formatstr(eGPUDataFormat data_format)
static int pygpu_buffer_dimensions_set(BPyGPUBuffer *self, PyObject *value, void *)
const char * PyC_StringEnum_FindIDFromValue(const PyC_StringEnumItems *items, const int value)
static PySequenceMethods pygpu_buffer__tp_as_sequence
static PyObject * pygpu_buffer__tp_new(PyTypeObject *, PyObject *args, PyObject *kwds)
static void pygpu_buffer_strides_calc(const eGPUDataFormat format, const int shape_len, const Py_ssize_t *shape, Py_ssize_t *r_strides)
static Py_ssize_t pygpu_buffer__sq_length(BPyGPUBuffer *self)
BPyGPUBuffer * BPyGPU_Buffer_CreatePyObject(const int format, const Py_ssize_t *shape, const int shape_len, void *buffer)
static int pygpu_buffer__tp_is_gc(BPyGPUBuffer *self)
static PyObject * pygpu_buffer_to_list(BPyGPUBuffer *self)
static int pygpu_buffer_ass_slice(BPyGPUBuffer *self, Py_ssize_t begin, Py_ssize_t end, PyObject *seq)
int PyC_ParseStringEnum(PyObject *o, void *p)
static PyObject * pygpu_buffer__sq_item(BPyGPUBuffer *self, Py_ssize_t i)
static bool pygpu_buffer_pyobj_as_shape(PyObject *shape_obj, Py_ssize_t r_shape[MAX_DIMENSIONS], Py_ssize_t *r_shape_len)
static PyMappingMethods pygpu_buffer__tp_as_mapping
union blender::BPyGPUBuffer::@121160014351146313222050217274041240110051113162 buf
PyObject_HEAD PyObject * parent