diff options
author | mano-wii <germano.costa@ig.com.br> | 2018-09-27 06:53:45 +0300 |
---|---|---|
committer | mano-wii <germano.costa@ig.com.br> | 2018-09-27 06:53:45 +0300 |
commit | da96336e5ffa146cc240d1e9fe3c3d98e41387d1 (patch) | |
tree | 2a88996d8bff7d01b05fd9d83f07598c21c2f79e /source/blender/python/gpu/gpu_py_element.c | |
parent | 1e647a570d9c42de915bc1204ff21ea5fa4e6b17 (diff) |
Python GPU module: Wrap GPUIndexBuf
Differential Revision D3714
Diffstat (limited to 'source/blender/python/gpu/gpu_py_element.c')
-rw-r--r-- | source/blender/python/gpu/gpu_py_element.c | 251 |
1 files changed, 251 insertions, 0 deletions
diff --git a/source/blender/python/gpu/gpu_py_element.c b/source/blender/python/gpu/gpu_py_element.c new file mode 100644 index 00000000000..1683def7ec8 --- /dev/null +++ b/source/blender/python/gpu/gpu_py_element.c @@ -0,0 +1,251 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file blender/python/gpu/gpu_py_element.c + * \ingroup bpygpu + * + * - Use ``bpygpu_`` for local API. + * - Use ``BPyGPU`` for public API. + */ + +#include <Python.h> + +#include "GPU_element.h" + +#include "BLI_math.h" + +#include "MEM_guardedalloc.h" + +#include "../generic/py_capi_utils.h" +#include "../generic/python_utildefines.h" + +#include "gpu_py_primitive.h" +#include "gpu_py_element.h" /* own include */ + + +/* -------------------------------------------------------------------- */ + +/** \name IndexBuf Type + * \{ */ + +static PyObject *bpygpu_IndexBuf_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds) +{ + bool ok = true; + + struct { + GPUPrimType type_id; + PyObject *seq; + } params; + + uint verts_per_prim; + uint index_len; + GPUIndexBufBuilder builder; + + static const char *_keywords[] = {"type", "seq", NULL}; + static _PyArg_Parser _parser = {"$O&O:IndexBuf.__new__", _keywords, 0}; + if (!_PyArg_ParseTupleAndKeywordsFast( + args, kwds, &_parser, + bpygpu_ParsePrimType, ¶ms.type_id, + ¶ms.seq)) + { + return NULL; + } + + verts_per_prim = GPU_indexbuf_primitive_len(params.type_id); + if (verts_per_prim == -1) { + PyErr_Format(PyExc_ValueError, + "The argument 'type' must be " + "'POINTS', 'LINES', 'TRIS' or 'LINES_ADJ'"); + return NULL; + } + + if (PyObject_CheckBuffer(params.seq)) { + Py_buffer pybuffer; + + if (PyObject_GetBuffer(params.seq, &pybuffer, PyBUF_FORMAT | PyBUF_ND) == -1) { + /* PyObject_GetBuffer already handles error messages. */ + return NULL; + } + + if (pybuffer.ndim != 1 && pybuffer.shape[1] != verts_per_prim) { + PyErr_Format(PyExc_ValueError, + "Each primitive must exactly %d indices", + verts_per_prim); + return NULL; + } + + bool format_error = pybuffer.itemsize != 4; + { + char *typestr = pybuffer.format; + if (ELEM(typestr[0], '<', '>', '|')) { + typestr += 1; + } + if (ELEM(typestr[0], 'f', 'd')) { + format_error = true; + } + } + + if (format_error) { + PyErr_Format(PyExc_ValueError, + "Each index must be an integer value with 4 bytes in size"); + return NULL; + } + + index_len = pybuffer.shape[0]; + if (pybuffer.ndim != 1) { + index_len *= pybuffer.shape[1]; + } + + /* The `vertex_len` parameter is only used for asserts in the Debug build. + /* Not very useful in python since scripts are often tested in Release build. + /* Use `INT_MAX` instead of the actual number of vertices. */ + GPU_indexbuf_init( + &builder, params.type_id, index_len, INT_MAX); + +#if 0 + uint *buf = pybuffer.buf; + for (uint i = index_len; i--; buf++) { + GPU_indexbuf_add_generic_vert(&builder, *buf); + } +#else + memcpy(builder.data, pybuffer.buf, index_len * sizeof(builder.data)); + builder.index_len = index_len; +#endif + PyBuffer_Release(&pybuffer); + } + else { + PyObject *seq_fast = PySequence_Fast( + params.seq, "Index Buffer Initialization"); + + if (seq_fast == NULL) { + return false; + } + + const uint seq_len = PySequence_Fast_GET_SIZE(seq_fast); + + PyObject **seq_items = PySequence_Fast_ITEMS(seq_fast); + + index_len = seq_len * verts_per_prim; + + /* The `vertex_len` parameter is only used for asserts in the Debug build. + /* Not very useful in python since scripts are often tested in Release build. + /* Use `INT_MAX` instead of the actual number of vertices. */ + GPU_indexbuf_init( + &builder, params.type_id, index_len, INT_MAX); + + if (verts_per_prim == 1) { + for (uint i = 0; i < seq_len; i++) { + GPU_indexbuf_add_generic_vert( + &builder, PyC_Long_AsU32(seq_items[i])); + } + } + else { + for (uint i = 0; i < seq_len; i++) { + PyObject *item = seq_items[i]; + if (!PyTuple_CheckExact(item)) { + PyErr_Format(PyExc_ValueError, + "expected a tuple, got %s", + Py_TYPE(item)->tp_name); + ok = false; + goto finally; + } + if (PyTuple_GET_SIZE(item) != verts_per_prim) { + PyErr_Format(PyExc_ValueError, + "Expected a Tuple of size %d, got %d", + PyTuple_GET_SIZE(item)); + ok = false; + goto finally; + } + + for (uint j = 0; j < verts_per_prim; j++) { + GPU_indexbuf_add_generic_vert( + &builder, + PyC_Long_AsU32(PyTuple_GET_ITEM(item, j))); + } + } + } + + if (PyErr_Occurred()) { + ok = false; + } + +finally: + + Py_DECREF(seq_fast); + } + + if (ok == false) { + MEM_freeN(builder.data); + return NULL; + } + + return BPyGPUIndexBuf_CreatePyObject(GPU_indexbuf_build(&builder)); +} + +static void bpygpu_IndexBuf_dealloc(BPyGPUIndexBuf *self) +{ + GPU_indexbuf_discard(self->elem); + Py_TYPE(self)->tp_free(self); +} + +PyDoc_STRVAR(py_gpu_element_doc, +"GPUIndexBuf(type, seq)\n" +"\n" +"Contains a VBO." +"\n" +" :param prim_type:\n" +" One of these primitive types: {\n" +" 'POINTS',\n" +" 'LINES',\n" +" 'TRIS',\n" +" 'LINE_STRIP_ADJ'}\n" +" :type type: `str`\n" +" :param seq: Sequence of integers.\n" +" :type buf: `Any 1D or 2D Sequence`\n" +); +PyTypeObject BPyGPUIndexBuf_Type = { + PyVarObject_HEAD_INIT(NULL, 0) + .tp_name = "GPUIndexBuf", + .tp_basicsize = sizeof(BPyGPUIndexBuf), + .tp_dealloc = (destructor)bpygpu_IndexBuf_dealloc, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_doc = py_gpu_element_doc, + .tp_new = bpygpu_IndexBuf_new, +}; + +/** \} */ + + +/* -------------------------------------------------------------------- */ + +/** \name Public API + * \{ */ + +PyObject *BPyGPUIndexBuf_CreatePyObject(GPUIndexBuf *elem) +{ + BPyGPUIndexBuf *self; + + self = PyObject_New(BPyGPUIndexBuf, &BPyGPUIndexBuf_Type); + self->elem = elem; + + return (PyObject *)self; +} + +/** \} */ |