diff options
Diffstat (limited to 'source/blender/python/gpu/gpu_py_framebuffer.c')
| -rw-r--r-- | source/blender/python/gpu/gpu_py_framebuffer.c | 546 |
1 files changed, 546 insertions, 0 deletions
diff --git a/source/blender/python/gpu/gpu_py_framebuffer.c b/source/blender/python/gpu/gpu_py_framebuffer.c new file mode 100644 index 00000000000..487f0f984cb --- /dev/null +++ b/source/blender/python/gpu/gpu_py_framebuffer.c @@ -0,0 +1,546 @@ +/* + * 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. + */ + +/** \file + * \ingroup bpygpu + * + * This file defines the framebuffer functionalities of the 'gpu' module + * used for off-screen OpenGL rendering. + * + * - Use ``bpygpu_`` for local API. + * - Use ``BPyGPU`` for public API. + */ + +#include <Python.h> + +#include "GPU_context.h" +#include "GPU_framebuffer.h" +#include "GPU_init_exit.h" + +#include "../generic/py_capi_utils.h" +#include "../generic/python_utildefines.h" +#include "../mathutils/mathutils.h" + +#include "gpu_py_api.h" +#include "gpu_py_texture.h" + +#include "gpu_py_framebuffer.h" /* own include */ + +/* -------------------------------------------------------------------- */ +/** \name GPUFrameBuffer Common Utilities + * \{ */ + +static int pygpu_framebuffer_valid_check(BPyGPUFrameBuffer *bpygpu_fb) +{ + if (UNLIKELY(bpygpu_fb->fb == NULL)) { + PyErr_SetString(PyExc_ReferenceError, +#ifdef BPYGPU_USE_GPUOBJ_FREE_METHOD + "GPU framebuffer was freed, no further access is valid" +#else + "GPU framebuffer: internal error" +#endif + ); + return -1; + } + return 0; +} + +#define PYGPU_FRAMEBUFFER_CHECK_OBJ(bpygpu) \ + { \ + if (UNLIKELY(pygpu_framebuffer_valid_check(bpygpu) == -1)) { \ + return NULL; \ + } \ + } \ + ((void)0) + +static void pygpu_framebuffer_free_if_possible(GPUFrameBuffer *fb) +{ + if (!fb) { + return; + } + + if (GPU_is_init()) { + GPU_framebuffer_free(fb); + } + else { + printf("PyFramebuffer freed after the context has been destroyed.\n"); + } +} + +/* Keep less than or equal to #FRAMEBUFFER_STACK_DEPTH */ +#define GPU_PY_FRAMEBUFFER_STACK_LEN 16 + +static bool pygpu_framebuffer_stack_push_and_bind_or_error(GPUFrameBuffer *fb) +{ + if (GPU_framebuffer_stack_level_get() >= GPU_PY_FRAMEBUFFER_STACK_LEN) { + PyErr_SetString( + PyExc_RuntimeError, + "Maximum framebuffer stack depth " STRINGIFY(GPU_PY_FRAMEBUFFER_STACK_LEN) " reached"); + return false; + } + GPU_framebuffer_push(GPU_framebuffer_active_get()); + GPU_framebuffer_bind(fb); + return true; +} + +static bool pygpu_framebuffer_stack_pop_and_restore_or_error(GPUFrameBuffer *fb) +{ + if (GPU_framebuffer_stack_level_get() == 0) { + PyErr_SetString(PyExc_RuntimeError, "Minimum framebuffer stack depth reached"); + return false; + } + + if (fb && !GPU_framebuffer_bound(fb)) { + PyErr_SetString(PyExc_RuntimeError, "Framebuffer is not bound"); + return false; + } + + GPUFrameBuffer *fb_prev = GPU_framebuffer_pop(); + GPU_framebuffer_bind(fb_prev); + return true; +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name Stack (Context Manager) + * + * Safer alternative to ensure balanced push/pop calls. + * + * \{ */ + +typedef struct { + PyObject_HEAD /* required python macro */ + BPyGPUFrameBuffer *py_fb; + int level; +} PyFrameBufferStackContext; + +static void pygpu_framebuffer_stack_context__tp_dealloc(PyFrameBufferStackContext *self) +{ + Py_DECREF(self->py_fb); + PyObject_DEL(self); +} + +static PyObject *pygpu_framebuffer_stack_context_enter(PyFrameBufferStackContext *self) +{ + PYGPU_FRAMEBUFFER_CHECK_OBJ(self->py_fb); + + /* sanity - should never happen */ + if (self->level != -1) { + PyErr_SetString(PyExc_RuntimeError, "Already in use"); + return NULL; + } + + if (!pygpu_framebuffer_stack_push_and_bind_or_error(self->py_fb->fb)) { + return NULL; + } + + self->level = GPU_framebuffer_stack_level_get(); + Py_RETURN_NONE; +} + +static PyObject *pygpu_framebuffer_stack_context_exit(PyFrameBufferStackContext *self, + PyObject *UNUSED(args)) +{ + PYGPU_FRAMEBUFFER_CHECK_OBJ(self->py_fb); + + /* sanity - should never happen */ + if (self->level == -1) { + fprintf(stderr, "Not yet in use\n"); + return NULL; + } + + const int level = GPU_framebuffer_stack_level_get(); + if (level != self->level) { + fprintf(stderr, "Level of bind mismatch, expected %d, got %d\n", self->level, level); + } + + if (!pygpu_framebuffer_stack_pop_and_restore_or_error(self->py_fb->fb)) { + return NULL; + } + Py_RETURN_NONE; +} + +static PyMethodDef pygpu_framebuffer_stack_context__tp_methods[] = { + {"__enter__", (PyCFunction)pygpu_framebuffer_stack_context_enter, METH_NOARGS}, + {"__exit__", (PyCFunction)pygpu_framebuffer_stack_context_exit, METH_VARARGS}, + {NULL}, +}; + +static PyTypeObject FramebufferStackContext_Type = { + PyVarObject_HEAD_INIT(NULL, 0).tp_name = "GPUFrameBufferStackContext", + .tp_basicsize = sizeof(PyFrameBufferStackContext), + .tp_dealloc = (destructor)pygpu_framebuffer_stack_context__tp_dealloc, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_methods = pygpu_framebuffer_stack_context__tp_methods, +}; + +PyDoc_STRVAR(pygpu_framebuffer_bind_doc, + ".. function:: bind()\n" + "\n" + " Context manager to ensure balanced bind calls, even in the case of an error.\n"); +static PyObject *pygpu_framebuffer_bind(BPyGPUFrameBuffer *self) +{ + PyFrameBufferStackContext *ret = PyObject_New(PyFrameBufferStackContext, + &FramebufferStackContext_Type); + ret->py_fb = self; + ret->level = -1; + Py_INCREF(self); + return (PyObject *)ret; +} + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name GPUFramebuffer Type + * \{ */ + +/* Fill in the GPUAttachment according to the PyObject parameter. + * PyObject *o can be NULL, Py_None, BPyGPUTexture or a dictionary containing the keyword "texture" + * and the optional keywords "layer" and "mip". + * Returns false on error. In this case, a python message will be raised and GPUAttachment will not + * be touched. */ +static bool pygpu_framebuffer_new_parse_arg(PyObject *o, GPUAttachment *r_attach) +{ + GPUAttachment tmp_attach = GPU_ATTACHMENT_NONE; + + if (!o || o == Py_None) { + /* Pass. */; + } + else if (BPyGPUTexture_Check(o)) { + if (!bpygpu_ParseTexture(o, &tmp_attach.tex)) { + return false; + } + } + else { + const char *c_texture = "texture"; + const char *c_layer = "layer"; + const char *c_mip = "mip"; + PyObject *key, *value; + Py_ssize_t pos = 0; + while (PyDict_Next(o, &pos, &key, &value)) { + if (!PyUnicode_Check(key)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return false; + } + + if (c_texture && _PyUnicode_EqualToASCIIString(key, c_texture)) { + /* Compare only once. */ + c_texture = NULL; + if (!bpygpu_ParseTexture(value, &tmp_attach.tex)) { + return false; + } + } + else if (c_layer && _PyUnicode_EqualToASCIIString(key, c_layer)) { + /* Compare only once. */ + c_layer = NULL; + tmp_attach.layer = PyLong_AsLong(value); + if (tmp_attach.layer == -1 && PyErr_Occurred()) { + return false; + } + } + else if (c_mip && _PyUnicode_EqualToASCIIString(key, c_mip)) { + /* Compare only once. */ + c_mip = NULL; + tmp_attach.mip = PyLong_AsLong(value); + if (tmp_attach.mip == -1 && PyErr_Occurred()) { + return false; + } + } + else { + PyErr_Format( + PyExc_TypeError, "'%U' is an invalid keyword argument for this attribute", key); + return false; + } + } + } + + *r_attach = tmp_attach; + return true; +} + +static PyObject *pygpu_framebuffer__tp_new(PyTypeObject *UNUSED(self), + PyObject *args, + PyObject *kwds) +{ + BPYGPU_IS_INIT_OR_ERROR_OBJ; + if (!GPU_context_active_get()) { + PyErr_SetString(PyExc_RuntimeError, "No active GPU context found"); + return NULL; + } + + PyObject *depth_attachment = NULL; + PyObject *color_attachements = NULL; + static const char *_keywords[] = {"depth_slot", "color_slots", NULL}; + static _PyArg_Parser _parser = {"|$OO:GPUFrameBuffer.__new__", _keywords, 0}; + if (!_PyArg_ParseTupleAndKeywordsFast( + args, kwds, &_parser, &depth_attachment, &color_attachements)) { + return NULL; + } + + /* Keep in sync with #GPU_FB_MAX_COLOR_ATTACHMENT. + * TODO: share the define. */ +#define BPYGPU_FB_MAX_COLOR_ATTACHMENT 6 + + GPUAttachment config[BPYGPU_FB_MAX_COLOR_ATTACHMENT + 1]; + + if (!pygpu_framebuffer_new_parse_arg(depth_attachment, &config[0])) { + return NULL; + } + else if (config[0].tex && !GPU_texture_depth(config[0].tex)) { + PyErr_SetString(PyExc_ValueError, "Depth texture with incompatible format"); + return NULL; + } + + int color_attachements_len = 0; + if (color_attachements && color_attachements != Py_None) { + if (PySequence_Check(color_attachements)) { + color_attachements_len = PySequence_Size(color_attachements); + if (color_attachements_len > BPYGPU_FB_MAX_COLOR_ATTACHMENT) { + PyErr_SetString( + PyExc_AttributeError, + "too many attachements, max is " STRINGIFY(BPYGPU_FB_MAX_COLOR_ATTACHMENT)); + return NULL; + } + + for (int i = 1; i <= color_attachements_len; i++) { + PyObject *o = PySequence_GetItem(color_attachements, i); + bool ok = pygpu_framebuffer_new_parse_arg(o, &config[i]); + Py_DECREF(o); + if (!ok) { + return NULL; + } + } + } + else { + if (!pygpu_framebuffer_new_parse_arg(color_attachements, &config[1])) { + return NULL; + } + color_attachements_len = 1; + } + } + + GPUFrameBuffer *fb_python = GPU_framebuffer_create("fb_python"); + GPU_framebuffer_config_array(fb_python, config, color_attachements_len + 1); + + return BPyGPUFrameBuffer_CreatePyObject(fb_python); +} + +PyDoc_STRVAR(pygpu_framebuffer_is_bound_doc, + "Checks if this is the active framebuffer in the context."); +static PyObject *pygpu_framebuffer_is_bound(BPyGPUFrameBuffer *self, void *UNUSED(type)) +{ + PYGPU_FRAMEBUFFER_CHECK_OBJ(self); + return PyBool_FromLong(GPU_framebuffer_bound(self->fb)); +} + +PyDoc_STRVAR(pygpu_framebuffer_clear_doc, + ".. method:: clear(color=None, depth=None, stencil=None)\n" + "\n" + " Fill color, depth and stencil textures with specific value.\n" + " Common values: color=(0.0, 0.0, 0.0, 1.0), depth=1.0, stencil=0.\n" + "\n" + " :arg color: float sequence each representing ``(r, g, b, a)``.\n" + " :type color: sequence of 3 or 4 floats\n" + " :arg depth: depth value.\n" + " :type depth: `float`\n" + " :arg stencil: stencil value.\n" + " :type stencil: `int`\n"); +static PyObject *pygpu_framebuffer_clear(BPyGPUFrameBuffer *self, PyObject *args, PyObject *kwds) +{ + PYGPU_FRAMEBUFFER_CHECK_OBJ(self); + + if (!GPU_framebuffer_bound(self->fb)) { + return NULL; + } + + PyObject *py_col = NULL; + PyObject *py_depth = NULL; + PyObject *py_stencil = NULL; + + static const char *_keywords[] = {"color", "depth", "stencil", NULL}; + static _PyArg_Parser _parser = {"|$OOO:clear", _keywords, 0}; + if (!_PyArg_ParseTupleAndKeywordsFast(args, kwds, &_parser, &py_col, &py_depth, &py_stencil)) { + return NULL; + } + + eGPUFrameBufferBits buffers = 0; + float col[4] = {0.0f, 0.0f, 0.0f, 1.0f}; + float depth = 1.0f; + uint stencil = 0; + + if (py_col && py_col != Py_None) { + if (mathutils_array_parse(col, 3, 4, py_col, "GPUFrameBuffer.clear(), invalid 'color' arg") == + -1) { + return NULL; + } + buffers |= GPU_COLOR_BIT; + } + + if (py_depth && py_depth != Py_None) { + depth = PyFloat_AsDouble(py_depth); + if (PyErr_Occurred()) { + return NULL; + } + buffers |= GPU_DEPTH_BIT; + } + + if (py_stencil && py_stencil != Py_None) { + if ((stencil = PyC_Long_AsU32(py_stencil)) == (uint)-1) { + return NULL; + } + buffers |= GPU_STENCIL_BIT; + } + + GPU_framebuffer_clear(self->fb, buffers, col, depth, stencil); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(pygpu_framebuffer_viewport_set_doc, + ".. function:: viewport_set(x, y, xsize, ysize)\n" + "\n" + " Set the viewport for this framebuffer object.\n" + " Note: The viewport state is not saved upon framebuffer rebind.\n" + "\n" + " :param x, y: lower left corner of the viewport_set rectangle, in pixels.\n" + " :param xsize, ysize: width and height of the viewport_set.\n" + " :type x, y, xsize, ysize: `int`\n"); +static PyObject *pygpu_framebuffer_viewport_set(BPyGPUFrameBuffer *self, + PyObject *args, + void *UNUSED(type)) +{ + int x, y, xsize, ysize; + if (!PyArg_ParseTuple(args, "iiii:viewport_set", &x, &y, &xsize, &ysize)) { + return NULL; + } + + GPU_framebuffer_viewport_set(self->fb, x, y, xsize, ysize); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(pygpu_framebuffer_viewport_get_doc, + ".. function:: viewport_get()\n" + "\n" + " Returns position and dimension to current viewport.\n"); +static PyObject *pygpu_framebuffer_viewport_get(BPyGPUFrameBuffer *self, void *UNUSED(type)) +{ + PYGPU_FRAMEBUFFER_CHECK_OBJ(self); + int viewport[4]; + GPU_framebuffer_viewport_get(self->fb, viewport); + + PyObject *ret = PyTuple_New(4); + PyTuple_SET_ITEMS(ret, + PyLong_FromLong(viewport[0]), + PyLong_FromLong(viewport[1]), + PyLong_FromLong(viewport[2]), + PyLong_FromLong(viewport[3])); + return ret; +} + +#ifdef BPYGPU_USE_GPUOBJ_FREE_METHOD +PyDoc_STRVAR(pygpu_framebuffer_free_doc, + ".. method:: free()\n" + "\n" + " Free the framebuffer object.\n" + " The framebuffer will no longer be accessible.\n"); +static PyObject *pygpu_framebuffer_free(BPyGPUFrameBuffer *self) +{ + PYGPU_FRAMEBUFFER_CHECK_OBJ(self); + pygpu_framebuffer_free_if_possible(self->fb); + self->fb = NULL; + Py_RETURN_NONE; +} +#endif + +static void BPyGPUFrameBuffer__tp_dealloc(BPyGPUFrameBuffer *self) +{ + pygpu_framebuffer_free_if_possible(self->fb); + Py_TYPE(self)->tp_free((PyObject *)self); +} + +static PyGetSetDef pygpu_framebuffer__tp_getseters[] = { + {"is_bound", + (getter)pygpu_framebuffer_is_bound, + (setter)NULL, + pygpu_framebuffer_is_bound_doc, + NULL}, + {NULL, NULL, NULL, NULL, NULL} /* Sentinel */ +}; + +static struct PyMethodDef pygpu_framebuffer__tp_methods[] = { + {"bind", (PyCFunction)pygpu_framebuffer_bind, METH_NOARGS, pygpu_framebuffer_bind_doc}, + {"clear", + (PyCFunction)pygpu_framebuffer_clear, + METH_VARARGS | METH_KEYWORDS, + pygpu_framebuffer_clear_doc}, + {"viewport_set", + (PyCFunction)pygpu_framebuffer_viewport_set, + METH_NOARGS, + pygpu_framebuffer_viewport_set_doc}, + {"viewport_get", + (PyCFunction)pygpu_framebuffer_viewport_get, + METH_VARARGS, + pygpu_framebuffer_viewport_get_doc}, +#ifdef BPYGPU_USE_GPUOBJ_FREE_METHOD + {"free", (PyCFunction)pygpu_framebuffer_free, METH_NOARGS, pygpu_framebuffer_free_doc}, +#endif + {NULL, NULL, 0, NULL}, +}; + +PyDoc_STRVAR(pygpu_framebuffer__tp_doc, + ".. class:: GPUFrameBuffer(depth_slot=None, color_slots=None)\n" + "\n" + " This object gives access to framebuffer functionallities.\n" + " When a 'layer' is specified in a argument, a single layer of a 3D or array " + "texture is attached to the frame-buffer.\n" + " For cube map textures, layer is translated into a cube map face.\n" + "\n" + " :arg depth_slot: GPUTexture to attach or a `dict` containing keywords: " + "'texture', 'layer' and 'mip'.\n" + " :type depth_slot: :class:`gpu.types.GPUTexture`, `dict` or `Nonetype`\n" + " :arg color_slots: Tuple where each item can be a GPUTexture or a `dict` " + "containing keywords: 'texture', 'layer' and 'mip'.\n" + " :type color_slots: `tuple` or `Nonetype`\n"); +PyTypeObject BPyGPUFrameBuffer_Type = { + PyVarObject_HEAD_INIT(NULL, 0).tp_name = "GPUFrameBuffer", + .tp_basicsize = sizeof(BPyGPUFrameBuffer), + .tp_dealloc = (destructor)BPyGPUFrameBuffer__tp_dealloc, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_doc = pygpu_framebuffer__tp_doc, + .tp_methods = pygpu_framebuffer__tp_methods, + .tp_getset = pygpu_framebuffer__tp_getseters, + .tp_new = pygpu_framebuffer__tp_new, +}; + +/** \} */ + +/* -------------------------------------------------------------------- */ +/** \name Public API + * \{ */ + +PyObject *BPyGPUFrameBuffer_CreatePyObject(GPUFrameBuffer *fb) +{ + BPyGPUFrameBuffer *self; + + self = PyObject_New(BPyGPUFrameBuffer, &BPyGPUFrameBuffer_Type); + self->fb = fb; + + return (PyObject *)self; +} + +/** \} */ + +#undef PYGPU_FRAMEBUFFER_CHECK_OBJ |