diff options
Diffstat (limited to 'source/blender/python')
61 files changed, 540 insertions, 278 deletions
diff --git a/source/blender/python/BPY_extern.h b/source/blender/python/BPY_extern.h index 8075e4ecd22..aecefa97423 100644 --- a/source/blender/python/BPY_extern.h +++ b/source/blender/python/BPY_extern.h @@ -34,7 +34,7 @@ void BPY_pyconstraint_exec(struct bPythonConstraint *con, // void BPY_pyconstraint_settings(void *arg1, void *arg2); void BPY_pyconstraint_target(struct bPythonConstraint *con, struct bConstraintTarget *ct); void BPY_pyconstraint_update(struct Object *owner, struct bConstraint *con); -int BPY_is_pyconstraint(struct Text *text); +bool BPY_is_pyconstraint(struct Text *text); // void BPY_free_pyconstraint_links(struct Text *text); /* global interpreter lock */ diff --git a/source/blender/python/CMakeLists.txt b/source/blender/python/CMakeLists.txt index 9f6ee359d67..f82499ba1d4 100644 --- a/source/blender/python/CMakeLists.txt +++ b/source/blender/python/CMakeLists.txt @@ -1,5 +1,9 @@ # SPDX-License-Identifier: GPL-2.0-or-later +if(WITH_PYTHON_MODULE) + add_definitions(-DPy_ENABLE_SHARED) +endif() + add_subdirectory(intern) add_subdirectory(generic) add_subdirectory(gpu) diff --git a/source/blender/python/bmesh/bmesh_py_api.c b/source/blender/python/bmesh/bmesh_py_api.c index 3ddab4bebd9..2e6d1698da9 100644 --- a/source/blender/python/bmesh/bmesh_py_api.c +++ b/source/blender/python/bmesh/bmesh_py_api.c @@ -160,7 +160,7 @@ static struct PyModuleDef BPy_BM_module_def = { BPy_BM_doc, /* m_doc */ 0, /* m_size */ BPy_BM_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/bmesh/bmesh_py_geometry.c b/source/blender/python/bmesh/bmesh_py_geometry.c index 5625812fbda..f2af8599807 100644 --- a/source/blender/python/bmesh/bmesh_py_geometry.c +++ b/source/blender/python/bmesh/bmesh_py_geometry.c @@ -66,7 +66,7 @@ static struct PyModuleDef BPy_BM_geometry_module_def = { BPy_BM_utils_doc, /* m_doc */ 0, /* m_size */ BPy_BM_geometry_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/bmesh/bmesh_py_ops.c b/source/blender/python/bmesh/bmesh_py_ops.c index 8b343b00342..37e2b009f55 100644 --- a/source/blender/python/bmesh/bmesh_py_ops.c +++ b/source/blender/python/bmesh/bmesh_py_ops.c @@ -267,7 +267,7 @@ static struct PyModuleDef BPy_BM_ops_module_def = { BPy_BM_ops_doc, /* m_doc */ 0, /* m_size */ BPy_BM_ops_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c index 972a782d650..364adb5458b 100644 --- a/source/blender/python/bmesh/bmesh_py_types.c +++ b/source/blender/python/bmesh/bmesh_py_types.c @@ -3740,7 +3740,7 @@ static struct PyModuleDef BPy_BM_types_module_def = { NULL, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ @@ -4273,10 +4273,10 @@ char *BPy_BMElem_StringFromHType(const char htype) /* -------------------------------------------------------------------- */ /* keep at bottom */ -/* this function is called on free, it should stay quite fast */ +/* This function is called on free, it should stay quite fast */ static void bm_dealloc_editmode_warn(BPy_BMesh *self) { if (self->flag & BPY_BMFLAG_IS_WRAPPED) { - /* currently nop - this works without warnings now */ + /* Currently NOP - this works without warnings now. */ } } diff --git a/source/blender/python/bmesh/bmesh_py_types_meshdata.c b/source/blender/python/bmesh/bmesh_py_types_meshdata.c index d4455fd3668..9f200734786 100644 --- a/source/blender/python/bmesh/bmesh_py_types_meshdata.c +++ b/source/blender/python/bmesh/bmesh_py_types_meshdata.c @@ -298,7 +298,7 @@ static int mathutils_bmloopcol_set(BaseMathObject *bmo, int UNUSED(subtype)) static int mathutils_bmloopcol_get_index(BaseMathObject *bmo, int subtype, int UNUSED(index)) { - /* lazy, avoid repeteing the case statement */ + /* Lazy, avoid repeating the case statement. */ if (mathutils_bmloopcol_get(bmo, subtype) == -1) { return -1; } @@ -309,7 +309,7 @@ static int mathutils_bmloopcol_set_index(BaseMathObject *bmo, int subtype, int i { const float f = bmo->data[index]; - /* lazy, avoid repeteing the case statement */ + /* Lazy, avoid repeating the case statement. */ if (mathutils_bmloopcol_get(bmo, subtype) == -1) { return -1; } diff --git a/source/blender/python/bmesh/bmesh_py_utils.c b/source/blender/python/bmesh/bmesh_py_utils.c index 1bee1342a07..6630eb4924e 100644 --- a/source/blender/python/bmesh/bmesh_py_utils.c +++ b/source/blender/python/bmesh/bmesh_py_utils.c @@ -822,7 +822,7 @@ static struct PyModuleDef BPy_BM_utils_module_def = { BPy_BM_utils_doc, /* m_doc */ 0, /* m_size */ BPy_BM_utils_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/generic/CMakeLists.txt b/source/blender/python/generic/CMakeLists.txt index 69bcfdfae4e..27b7ad28943 100644 --- a/source/blender/python/generic/CMakeLists.txt +++ b/source/blender/python/generic/CMakeLists.txt @@ -7,12 +7,11 @@ set(INC ../../gpu ../../makesdna ../../makesrna - ../../../../intern/glew-mx ../../../../intern/guardedalloc ) set(INC_SYS - ${GLEW_INCLUDE_PATH} + ${Epoxy_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} ) @@ -41,11 +40,9 @@ set(SRC ) set(LIB - ${GLEW_LIBRARY} + ${Epoxy_LIBRARIES} ${PYTHON_LINKFLAGS} ${PYTHON_LIBRARIES} ) -add_definitions(${GL_DEFINITIONS}) - blender_add_lib(bf_python_ext "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") diff --git a/source/blender/python/generic/bgl.c b/source/blender/python/generic/bgl.c index f5c1f060e80..36ab1e86d92 100644 --- a/source/blender/python/generic/bgl.c +++ b/source/blender/python/generic/bgl.c @@ -19,7 +19,7 @@ #include "../generic/py_capi_utils.h" -#include "glew-mx.h" +#include <epoxy/gl.h> #include "bgl.h" @@ -1397,7 +1397,7 @@ static struct PyModuleDef BGL_module_def = { NULL, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/generic/bl_math_py_api.c b/source/blender/python/generic/bl_math_py_api.c index 0f0a2bf0ed1..19958a99df9 100644 --- a/source/blender/python/generic/bl_math_py_api.c +++ b/source/blender/python/generic/bl_math_py_api.c @@ -133,7 +133,7 @@ static struct PyModuleDef M_bl_math_module_def = { M_bl_math_doc, /* m_doc */ 0, /* m_size */ M_bl_math_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/generic/blf_py_api.c b/source/blender/python/generic/blf_py_api.c index 060b7758ea9..11b71256327 100644 --- a/source/blender/python/generic/blf_py_api.c +++ b/source/blender/python/generic/blf_py_api.c @@ -465,7 +465,7 @@ static struct PyModuleDef BLF_module_def = { BLF_doc, /* m_doc */ 0, /* m_size */ BLF_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/generic/idprop_py_api.c b/source/blender/python/generic/idprop_py_api.c index 3f880da2f56..333ab9487d1 100644 --- a/source/blender/python/generic/idprop_py_api.c +++ b/source/blender/python/generic/idprop_py_api.c @@ -2119,7 +2119,7 @@ static struct PyModuleDef IDProp_types_module_def = { NULL, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ @@ -2168,7 +2168,7 @@ static struct PyModuleDef IDProp_module_def = { IDProp_module_doc, /* m_doc */ 0, /* m_size */ IDProp_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/generic/imbuf_py_api.c b/source/blender/python/generic/imbuf_py_api.c index e6d90c46866..056af83cc49 100644 --- a/source/blender/python/generic/imbuf_py_api.c +++ b/source/blender/python/generic/imbuf_py_api.c @@ -570,7 +570,7 @@ static struct PyModuleDef IMB_module_def = { IMB_doc, /* m_doc */ 0, /* m_size */ IMB_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ @@ -614,7 +614,7 @@ static struct PyModuleDef IMB_types_module_def = { IMB_types_doc, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/generic/py_capi_utils.c b/source/blender/python/generic/py_capi_utils.c index 4c842d82972..681c5404ed9 100644 --- a/source/blender/python/generic/py_capi_utils.c +++ b/source/blender/python/generic/py_capi_utils.c @@ -28,8 +28,8 @@ # include "BLI_string.h" -/* Only for BLI_strncpy_wchar_from_utf8, - * should replace with py funcs but too late in release now. */ +/* Only for #BLI_strncpy_wchar_from_utf8, + * should replace with Python functions but too late in release now. */ # include "BLI_string_utf8.h" #endif @@ -928,7 +928,7 @@ PyObject *PyC_ExceptionBuffer(void) PySys_SetObject("stderr", string_io); PyErr_Restore(error_type, error_value, error_traceback); - /* Printing clears (call #PyErr_Clear as well to ensure it's cleared). */ + /* Printing clears (call #PyErr_Clear as well to ensure it's cleared). */ Py_XINCREF(error_type); Py_XINCREF(error_value); Py_XINCREF(error_traceback); diff --git a/source/blender/python/generic/py_capi_utils.h b/source/blender/python/generic/py_capi_utils.h index ecb6db2b82c..91ebef8d0b0 100644 --- a/source/blender/python/generic/py_capi_utils.h +++ b/source/blender/python/generic/py_capi_utils.h @@ -215,7 +215,6 @@ int PyC_CheckArgs_DeepCopy(PyObject *args); /* Integer parsing (with overflow checks), -1 on error. */ /** - * * Comparison with #PyObject_IsTrue * ================================ * diff --git a/source/blender/python/gpu/CMakeLists.txt b/source/blender/python/gpu/CMakeLists.txt index 8ccb29beb13..e9db5c8716b 100644 --- a/source/blender/python/gpu/CMakeLists.txt +++ b/source/blender/python/gpu/CMakeLists.txt @@ -8,12 +8,11 @@ set(INC ../../gpu ../../imbuf ../../makesdna - ../../../../intern/glew-mx ../../../../intern/guardedalloc ) set(INC_SYS - ${GLEW_INCLUDE_PATH} + ${Epoxy_INCLUDE_DIRS} ${PYTHON_INCLUDE_DIRS} ) @@ -59,10 +58,9 @@ set(SRC ) set(LIB + ${Epoxy_LIBRARIES} ${PYTHON_LINKFLAGS} ${PYTHON_LIBRARIES} ) -add_definitions(${GL_DEFINITIONS}) - blender_add_lib(bf_python_gpu "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") diff --git a/source/blender/python/gpu/gpu_py_batch.c b/source/blender/python/gpu/gpu_py_batch.c index 533e5154d83..879e1c0ce8b 100644 --- a/source/blender/python/gpu/gpu_py_batch.c +++ b/source/blender/python/gpu/gpu_py_batch.c @@ -127,7 +127,7 @@ PyDoc_STRVAR(pygpu_batch_vertbuf_add_doc, " vertex buffer for vertex positions and vertex normals.\n" " Current a batch can have at most " STRINGIFY(GPU_BATCH_VBO_MAX_LEN) " vertex buffers.\n" "\n" -" :param buf: The vertex buffer that will be added to the batch.\n" +" :arg buf: The vertex buffer that will be added to the batch.\n" " :type buf: :class:`gpu.types.GPUVertBuf`\n" ); static PyObject *pygpu_batch_vertbuf_add(BPyGPUBatch *self, BPyGPUVertBuf *py_buf) @@ -171,7 +171,7 @@ PyDoc_STRVAR( " This function does not need to be called when you always\n" " set the shader when calling :meth:`gpu.types.GPUBatch.draw`.\n" "\n" - " :param program: The program/shader the batch will use in future draw calls.\n" + " :arg program: The program/shader the batch will use in future draw calls.\n" " :type program: :class:`gpu.types.GPUShader`\n"); static PyObject *pygpu_batch_program_set(BPyGPUBatch *self, BPyGPUShader *py_shader) { @@ -209,7 +209,7 @@ PyDoc_STRVAR(pygpu_batch_draw_doc, "\n" " Run the drawing program with the parameters assigned to the batch.\n" "\n" - " :param program: Program that performs the drawing operations.\n" + " :arg program: Program that performs the drawing operations.\n" " If ``None`` is passed, the last program set to this batch will run.\n" " :type program: :class:`gpu.types.GPUShader`\n"); static PyObject *pygpu_batch_draw(BPyGPUBatch *self, PyObject *args) diff --git a/source/blender/python/gpu/gpu_py_buffer.c b/source/blender/python/gpu/gpu_py_buffer.c index 020535d002a..9a415b7f2c4 100644 --- a/source/blender/python/gpu/gpu_py_buffer.c +++ b/source/blender/python/gpu/gpu_py_buffer.c @@ -100,7 +100,7 @@ static bool pygpu_buffer_pyobj_as_shape(PyObject *shape_obj, } else { PyErr_Format(PyExc_TypeError, - "invalid second argument argument expected a sequence " + "invalid second argument expected a sequence " "or an int, not a %.200s", Py_TYPE(shape_obj)->tp_name); } @@ -655,7 +655,7 @@ PyDoc_STRVAR( "\n" " :arg format: Format type to interpret the buffer.\n" " Possible values are `FLOAT`, `INT`, `UINT`, `UBYTE`, `UINT_24_8` and `10_11_11_REV`.\n" - " :type type: str\n" + " :type format: str\n" " :arg dimensions: Array describing the dimensions.\n" " :type dimensions: int\n" " :arg data: Optional data array.\n" diff --git a/source/blender/python/gpu/gpu_py_element.c b/source/blender/python/gpu/gpu_py_element.c index d52a97c0c84..46f1d4d49eb 100644 --- a/source/blender/python/gpu/gpu_py_element.c +++ b/source/blender/python/gpu/gpu_py_element.c @@ -180,7 +180,7 @@ PyDoc_STRVAR(pygpu_IndexBuf__tp_doc, " :arg type: The primitive type this index buffer is composed of.\n" " Possible values are `POINTS`, `LINES`, `TRIS` and `LINE_STRIP_ADJ`.\n" " :type type: str\n" - " :param seq: Indices this index buffer will contain.\n" + " :arg seq: Indices this index buffer will contain.\n" " Whether a 1D or 2D sequence is required depends on the type.\n" " Optionally the sequence can support the buffer protocol.\n" " :type seq: 1D or 2D sequence\n"); diff --git a/source/blender/python/gpu/gpu_py_framebuffer.c b/source/blender/python/gpu/gpu_py_framebuffer.c index 9bb2a9137f4..2de8c680b23 100644 --- a/source/blender/python/gpu/gpu_py_framebuffer.c +++ b/source/blender/python/gpu/gpu_py_framebuffer.c @@ -421,9 +421,10 @@ PyDoc_STRVAR(pygpu_framebuffer_viewport_set_doc, " 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"); + " :arg x, y: lower left corner of the viewport_set rectangle, in pixels.\n" + " :type x, y: int\n" + " :arg xsize, ysize: width and height of the viewport_set.\n" + " :type xsize, ysize: int\n"); static PyObject *pygpu_framebuffer_viewport_set(BPyGPUFrameBuffer *self, PyObject *args, void *UNUSED(type)) @@ -462,16 +463,16 @@ PyDoc_STRVAR( "\n" " Read a block of pixels from the frame buffer.\n" "\n" - " :param x, y: Lower left corner of a rectangular block of pixels.\n" - " :param xsize, ysize: Dimensions of the pixel rectangle.\n" + " :arg x, y: Lower left corner of a rectangular block of pixels.\n" + " :arg xsize, ysize: Dimensions of the pixel rectangle.\n" " :type x, y, xsize, ysize: int\n" - " :param channels: Number of components to read.\n" + " :arg channels: Number of components to read.\n" " :type channels: int\n" - " :param slot: The framebuffer slot to read data from.\n" + " :arg slot: The framebuffer slot to read data from.\n" " :type slot: int\n" - " :param format: The format that describes the content of a single channel.\n" + " :arg format: The format that describes the content of a single channel.\n" " Possible values are `FLOAT`, `INT`, `UINT`, `UBYTE`, `UINT_24_8` and `10_11_11_REV`.\n" - " :type type: str\n" + " :type format: str\n" " :arg data: Optional Buffer object to fill with the pixels values.\n" " :type data: :class:`gpu.types.Buffer`\n" " :return: The Buffer with the read pixels.\n" @@ -569,9 +570,10 @@ PyDoc_STRVAR(pygpu_framebuffer_read_depth_doc, "\n" " Read a pixel depth block from the frame buffer.\n" "\n" - " :param x, y: Lower left corner of a rectangular block of pixels.\n" - " :param xsize, ysize: Dimensions of the pixel rectangle.\n" - " :type x, y, xsize, ysize: int\n" + " :arg x, y: Lower left corner of a rectangular block of pixels.\n" + " :type x, y: int\n" + " :arg xsize, ysize: Dimensions of the pixel rectangle.\n" + " :type xsize, ysize: int\n" " :arg data: Optional Buffer object to fill with the pixels values.\n" " :type data: :class:`gpu.types.Buffer`\n" " :return: The Buffer with the read pixels.\n" diff --git a/source/blender/python/gpu/gpu_py_matrix.c b/source/blender/python/gpu/gpu_py_matrix.c index a47e3dc8a5f..18925a101da 100644 --- a/source/blender/python/gpu/gpu_py_matrix.c +++ b/source/blender/python/gpu/gpu_py_matrix.c @@ -266,7 +266,7 @@ PyDoc_STRVAR(pygpu_matrix_multiply_matrix_doc, "\n" " Multiply the current stack matrix.\n" "\n" - " :param matrix: A 4x4 matrix.\n" + " :arg matrix: A 4x4 matrix.\n" " :type matrix: :class:`mathutils.Matrix`\n"); static PyObject *pygpu_matrix_multiply_matrix(PyObject *UNUSED(self), PyObject *value) { @@ -283,7 +283,7 @@ PyDoc_STRVAR(pygpu_matrix_scale_doc, "\n" " Scale the current stack matrix.\n" "\n" - " :param scale: Scale the current stack matrix.\n" + " :arg scale: Scale the current stack matrix.\n" " :type scale: sequence of 2 or 3 floats\n"); static PyObject *pygpu_matrix_scale(PyObject *UNUSED(self), PyObject *value) { @@ -305,7 +305,7 @@ static PyObject *pygpu_matrix_scale(PyObject *UNUSED(self), PyObject *value) PyDoc_STRVAR(pygpu_matrix_scale_uniform_doc, ".. function:: scale_uniform(scale)\n" "\n" - " :param scale: Scale the current stack matrix.\n" + " :arg scale: Scale the current stack matrix.\n" " :type scale: float\n"); static PyObject *pygpu_matrix_scale_uniform(PyObject *UNUSED(self), PyObject *value) { @@ -323,7 +323,7 @@ PyDoc_STRVAR(pygpu_matrix_translate_doc, "\n" " Scale the current stack matrix.\n" "\n" - " :param offset: Translate the current stack matrix.\n" + " :arg offset: Translate the current stack matrix.\n" " :type offset: sequence of 2 or 3 floats\n"); static PyObject *pygpu_matrix_translate(PyObject *UNUSED(self), PyObject *value) { @@ -373,7 +373,7 @@ PyDoc_STRVAR(pygpu_matrix_load_matrix_doc, "\n" " Load a matrix into the stack.\n" "\n" - " :param matrix: A 4x4 matrix.\n" + " :arg matrix: A 4x4 matrix.\n" " :type matrix: :class:`mathutils.Matrix`\n"); static PyObject *pygpu_matrix_load_matrix(PyObject *UNUSED(self), PyObject *value) { @@ -390,7 +390,7 @@ PyDoc_STRVAR(pygpu_matrix_load_projection_matrix_doc, "\n" " Load a projection matrix into the stack.\n" "\n" - " :param matrix: A 4x4 matrix.\n" + " :arg matrix: A 4x4 matrix.\n" " :type matrix: :class:`mathutils.Matrix`\n"); static PyObject *pygpu_matrix_load_projection_matrix(PyObject *UNUSED(self), PyObject *value) { diff --git a/source/blender/python/gpu/gpu_py_select.c b/source/blender/python/gpu/gpu_py_select.c index 8869ea38e32..6d11e94433e 100644 --- a/source/blender/python/gpu/gpu_py_select.c +++ b/source/blender/python/gpu/gpu_py_select.c @@ -31,7 +31,7 @@ PyDoc_STRVAR(pygpu_select_load_id_doc, "\n" " Set the selection ID.\n" "\n" - " :param id: Number (32-bit uint).\n" + " :arg id: Number (32-bit uint).\n" " :type select: int\n"); static PyObject *pygpu_select_load_id(PyObject *UNUSED(self), PyObject *value) { diff --git a/source/blender/python/gpu/gpu_py_shader.c b/source/blender/python/gpu/gpu_py_shader.c index e3f789aa58d..a57b00e671e 100644 --- a/source/blender/python/gpu/gpu_py_shader.c +++ b/source/blender/python/gpu/gpu_py_shader.c @@ -16,6 +16,7 @@ #include "GPU_uniform_buffer.h" #include "../generic/py_capi_utils.h" +#include "../generic/python_utildefines.h" #include "../mathutils/mathutils.h" #include "gpu_py.h" @@ -30,52 +31,40 @@ * \{ */ #define PYDOC_BUILTIN_SHADER_DESCRIPTION \ - "``2D_FLAT_COLOR``\n" \ - " :Attributes: vec2 pos, vec4 color\n" \ - " :Uniforms: none\n" \ - "``2D_IMAGE``\n" \ - " :Attributes: vec2 pos, vec2 texCoord\n" \ - " :Uniforms: sampler2D image\n" \ - "``2D_SMOOTH_COLOR``\n" \ - " :Attributes: vec2 pos, vec4 color\n" \ - " :Uniforms: none\n" \ - "``2D_UNIFORM_COLOR``\n" \ - " :Attributes: vec2 pos\n" \ - " :Uniforms: vec4 color\n" \ - "``3D_FLAT_COLOR``\n" \ + "``FLAT_COLOR``\n" \ " :Attributes: vec3 pos, vec4 color\n" \ " :Uniforms: none\n" \ - "``3D_IMAGE``\n" \ + "``IMAGE``\n" \ " :Attributes: vec3 pos, vec2 texCoord\n" \ " :Uniforms: sampler2D image\n" \ - "``3D_SMOOTH_COLOR``\n" \ + "``IMAGE_COLOR``\n" \ + " :Attributes: vec3 pos, vec2 texCoord\n" \ + " :Uniforms: sampler2D image, vec4 color\n" \ + "``SMOOTH_COLOR``\n" \ " :Attributes: vec3 pos, vec4 color\n" \ " :Uniforms: none\n" \ - "``3D_UNIFORM_COLOR``\n" \ + "``UNIFORM_COLOR``\n" \ " :Attributes: vec3 pos\n" \ " :Uniforms: vec4 color\n" \ - "``3D_POLYLINE_FLAT_COLOR``\n" \ + "``POLYLINE_FLAT_COLOR``\n" \ " :Attributes: vec3 pos, vec4 color\n" \ " :Uniforms: vec2 viewportSize, float lineWidth\n" \ - "``3D_POLYLINE_SMOOTH_COLOR``\n" \ + "``POLYLINE_SMOOTH_COLOR``\n" \ " :Attributes: vec3 pos, vec4 color\n" \ " :Uniforms: vec2 viewportSize, float lineWidth\n" \ - "``3D_POLYLINE_UNIFORM_COLOR``\n" \ + "``POLYLINE_UNIFORM_COLOR``\n" \ " :Attributes: vec3 pos\n" \ " :Uniforms: vec2 viewportSize, float lineWidth\n" static const struct PyC_StringEnumItems pygpu_shader_builtin_items[] = { - {GPU_SHADER_2D_FLAT_COLOR, "2D_FLAT_COLOR"}, - {GPU_SHADER_2D_IMAGE, "2D_IMAGE"}, - {GPU_SHADER_2D_SMOOTH_COLOR, "2D_SMOOTH_COLOR"}, - {GPU_SHADER_2D_UNIFORM_COLOR, "2D_UNIFORM_COLOR"}, - {GPU_SHADER_3D_FLAT_COLOR, "3D_FLAT_COLOR"}, - {GPU_SHADER_3D_IMAGE, "3D_IMAGE"}, - {GPU_SHADER_3D_SMOOTH_COLOR, "3D_SMOOTH_COLOR"}, - {GPU_SHADER_3D_UNIFORM_COLOR, "3D_UNIFORM_COLOR"}, - {GPU_SHADER_3D_POLYLINE_FLAT_COLOR, "3D_POLYLINE_FLAT_COLOR"}, - {GPU_SHADER_3D_POLYLINE_SMOOTH_COLOR, "3D_POLYLINE_SMOOTH_COLOR"}, - {GPU_SHADER_3D_POLYLINE_UNIFORM_COLOR, "3D_POLYLINE_UNIFORM_COLOR"}, + {GPU_SHADER_3D_FLAT_COLOR, "FLAT_COLOR"}, + {GPU_SHADER_3D_IMAGE, "IMAGE"}, + {GPU_SHADER_3D_IMAGE_COLOR, "IMAGE_COLOR"}, + {GPU_SHADER_3D_SMOOTH_COLOR, "SMOOTH_COLOR"}, + {GPU_SHADER_3D_UNIFORM_COLOR, "UNIFORM_COLOR"}, + {GPU_SHADER_3D_POLYLINE_FLAT_COLOR, "POLYLINE_FLAT_COLOR"}, + {GPU_SHADER_3D_POLYLINE_SMOOTH_COLOR, "POLYLINE_SMOOTH_COLOR"}, + {GPU_SHADER_3D_POLYLINE_UNIFORM_COLOR, "POLYLINE_UNIFORM_COLOR"}, {0, NULL}, }; @@ -174,7 +163,7 @@ PyDoc_STRVAR(pygpu_shader_uniform_from_name_doc, "\n" " Get uniform location by name.\n" "\n" - " :param name: Name of the uniform variable whose location is to be queried.\n" + " :arg name: Name of the uniform variable whose location is to be queried.\n" " :type name: str\n" " :return: Location of the uniform variable.\n" " :rtype: int\n"); @@ -195,16 +184,15 @@ static PyObject *pygpu_shader_uniform_from_name(BPyGPUShader *self, PyObject *ar return PyLong_FromLong(uniform); } -PyDoc_STRVAR( - pygpu_shader_uniform_block_from_name_doc, - ".. method:: uniform_block_from_name(name)\n" - "\n" - " Get uniform block location by name.\n" - "\n" - " :param name: Name of the uniform block variable whose location is to be queried.\n" - " :type name: str\n" - " :return: The location of the uniform block variable.\n" - " :rtype: int\n"); +PyDoc_STRVAR(pygpu_shader_uniform_block_from_name_doc, + ".. method:: uniform_block_from_name(name)\n" + "\n" + " Get uniform block location by name.\n" + "\n" + " :arg name: Name of the uniform block variable whose location is to be queried.\n" + " :type name: str\n" + " :return: The location of the uniform block variable.\n" + " :rtype: int\n"); static PyObject *pygpu_shader_uniform_block_from_name(BPyGPUShader *self, PyObject *arg) { const char *name = PyUnicode_AsUTF8(arg); @@ -256,11 +244,11 @@ PyDoc_STRVAR(pygpu_shader_uniform_vector_float_doc, "\n" " Set the buffer to fill the uniform.\n" "\n" - " :param location: Location of the uniform variable to be modified.\n" + " :arg location: Location of the uniform variable to be modified.\n" " :type location: int\n" - " :param buffer: The data that should be set. Can support the buffer protocol.\n" + " :arg buffer: The data that should be set. Can support the buffer protocol.\n" " :type buffer: sequence of floats\n" - " :param length: Size of the uniform data type:\n\n" + " :arg length: Size of the uniform data type:\n\n" " - 1: float\n" " - 2: vec2 or float[2]\n" " - 3: vec3 or float[3]\n" @@ -268,7 +256,7 @@ PyDoc_STRVAR(pygpu_shader_uniform_vector_float_doc, " - 9: mat3\n" " - 16: mat4\n" " :type length: int\n" - " :param count: Specifies the number of elements, vector or matrices that are to " + " :arg count: Specifies the number of elements, vector or matrices that are to " "be modified.\n" " :type count: int\n"); static PyObject *pygpu_shader_uniform_vector_float(BPyGPUShader *self, PyObject *args) @@ -282,6 +270,7 @@ static PyObject *pygpu_shader_uniform_vector_float(BPyGPUShader *self, PyObject return NULL; } + GPU_shader_bind(self->shader); GPU_shader_uniform_vector(self->shader, location, length, count, pybuffer.buf); PyBuffer_Release(&pybuffer); @@ -304,6 +293,7 @@ static PyObject *pygpu_shader_uniform_vector_int(BPyGPUShader *self, PyObject *a return NULL; } + GPU_shader_bind(self->shader); GPU_shader_uniform_vector_int(self->shader, location, length, count, pybuffer.buf); PyBuffer_Release(&pybuffer); @@ -312,14 +302,14 @@ static PyObject *pygpu_shader_uniform_vector_int(BPyGPUShader *self, PyObject *a } PyDoc_STRVAR(pygpu_shader_uniform_bool_doc, - ".. method:: uniform_bool(name, seq)\n" + ".. method:: uniform_bool(name, value)\n" "\n" " Specify the value of a uniform variable for the current program object.\n" "\n" - " :param name: Name of the uniform variable whose value is to be changed.\n" + " :arg name: Name of the uniform variable whose value is to be changed.\n" " :type name: str\n" - " :param seq: Value that will be used to update the specified uniform variable.\n" - " :type seq: sequence of bools\n"); + " :arg value: Value that will be used to update the specified uniform variable.\n" + " :type value: bool or sequence of bools\n"); static PyObject *pygpu_shader_uniform_bool(BPyGPUShader *self, PyObject *args) { const char *error_prefix = "GPUShader.uniform_bool"; @@ -335,15 +325,14 @@ static PyObject *pygpu_shader_uniform_bool(BPyGPUShader *self, PyObject *args) int values[4]; int length; - int ret; - { + int ret = -1; + if (PySequence_Check(params.seq)) { PyObject *seq_fast = PySequence_Fast(params.seq, error_prefix); if (seq_fast == NULL) { PyErr_Format(PyExc_TypeError, "%s: expected a sequence, got %s", error_prefix, Py_TYPE(params.seq)->tp_name); - ret = -1; } else { length = PySequence_Fast_GET_SIZE(seq_fast); @@ -352,7 +341,6 @@ static PyObject *pygpu_shader_uniform_bool(BPyGPUShader *self, PyObject *args) "%s: invalid sequence length. expected 1..4, got %d", error_prefix, length); - ret = -1; } else { ret = PyC_AsArray_FAST( @@ -361,6 +349,15 @@ static PyObject *pygpu_shader_uniform_bool(BPyGPUShader *self, PyObject *args) Py_DECREF(seq_fast); } } + else if (((values[0] = (int)PyLong_AsLong(params.seq)) != -1) && ELEM(values[0], 0, 1)) { + length = 1; + ret = 0; + } + else { + PyErr_Format( + PyExc_ValueError, "expected a bool or sequence, got %s", Py_TYPE(params.seq)->tp_name); + } + if (ret == -1) { return NULL; } @@ -371,6 +368,7 @@ static PyObject *pygpu_shader_uniform_bool(BPyGPUShader *self, PyObject *args) return NULL; } + GPU_shader_bind(self->shader); GPU_shader_uniform_vector_int(self->shader, location, length, 1, values); Py_RETURN_NONE; @@ -381,9 +379,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_float_doc, "\n" " Specify the value of a uniform variable for the current program object.\n" "\n" - " :param name: Name of the uniform variable whose value is to be changed.\n" + " :arg name: Name of the uniform variable whose value is to be changed.\n" " :type name: str\n" - " :param value: Value that will be used to update the specified uniform variable.\n" + " :arg value: Value that will be used to update the specified uniform variable.\n" " :type value: single number or sequence of numbers\n"); static PyObject *pygpu_shader_uniform_float(BPyGPUShader *self, PyObject *args) { @@ -440,6 +438,7 @@ static PyObject *pygpu_shader_uniform_float(BPyGPUShader *self, PyObject *args) return NULL; } + GPU_shader_bind(self->shader); GPU_shader_uniform_vector(self->shader, location, length, 1, values); Py_RETURN_NONE; @@ -450,9 +449,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_int_doc, "\n" " Specify the value of a uniform variable for the current program object.\n" "\n" - " :param name: name of the uniform variable whose value is to be changed.\n" + " :arg name: name of the uniform variable whose value is to be changed.\n" " :type name: str\n" - " :param seq: Value that will be used to update the specified uniform variable.\n" + " :arg seq: Value that will be used to update the specified uniform variable.\n" " :type seq: sequence of numbers\n"); static PyObject *pygpu_shader_uniform_int(BPyGPUShader *self, PyObject *args) { @@ -511,6 +510,7 @@ static PyObject *pygpu_shader_uniform_int(BPyGPUShader *self, PyObject *args) return NULL; } + GPU_shader_bind(self->shader); GPU_shader_uniform_vector_int(self->shader, location, length, 1, values); Py_RETURN_NONE; @@ -521,9 +521,9 @@ PyDoc_STRVAR(pygpu_shader_uniform_sampler_doc, "\n" " Specify the value of a texture uniform variable for the current GPUShader.\n" "\n" - " :param name: name of the uniform variable whose texture is to be specified.\n" + " :arg name: name of the uniform variable whose texture is to be specified.\n" " :type name: str\n" - " :param texture: Texture to attach.\n" + " :arg texture: Texture to attach.\n" " :type texture: :class:`gpu.types.GPUTexture`\n"); static PyObject *pygpu_shader_uniform_sampler(BPyGPUShader *self, PyObject *args) { @@ -534,6 +534,7 @@ static PyObject *pygpu_shader_uniform_sampler(BPyGPUShader *self, PyObject *args return NULL; } + GPU_shader_bind(self->shader); int slot = GPU_shader_get_texture_binding(self->shader, name); GPU_texture_bind(py_texture->tex, slot); GPU_shader_uniform_1i(self->shader, name, slot); @@ -547,9 +548,9 @@ PyDoc_STRVAR( "\n" " Specify the value of an uniform buffer object variable for the current GPUShader.\n" "\n" - " :param name: name of the uniform variable whose UBO is to be specified.\n" + " :arg name: name of the uniform variable whose UBO is to be specified.\n" " :type name: str\n" - " :param ubo: Uniform Buffer to attach.\n" + " :arg ubo: Uniform Buffer to attach.\n" " :type texture: :class:`gpu.types.GPUUniformBuf`\n"); static PyObject *pygpu_shader_uniform_block(BPyGPUShader *self, PyObject *args) { @@ -568,21 +569,21 @@ static PyObject *pygpu_shader_uniform_block(BPyGPUShader *self, PyObject *args) return NULL; } + GPU_shader_bind(self->shader); GPU_uniformbuf_bind(py_ubo->ubo, binding); Py_RETURN_NONE; } -PyDoc_STRVAR( - pygpu_shader_attr_from_name_doc, - ".. method:: attr_from_name(name)\n" - "\n" - " Get attribute location by name.\n" - "\n" - " :param name: The name of the attribute variable whose location is to be queried.\n" - " :type name: str\n" - " :return: The location of an attribute variable.\n" - " :rtype: int\n"); +PyDoc_STRVAR(pygpu_shader_attr_from_name_doc, + ".. method:: attr_from_name(name)\n" + "\n" + " Get attribute location by name.\n" + "\n" + " :arg name: The name of the attribute variable whose location is to be queried.\n" + " :type name: str\n" + " :return: The location of an attribute variable.\n" + " :rtype: int\n"); static PyObject *pygpu_shader_attr_from_name(BPyGPUShader *self, PyObject *arg) { const char *name = PyUnicode_AsUTF8(arg); @@ -600,20 +601,58 @@ static PyObject *pygpu_shader_attr_from_name(BPyGPUShader *self, PyObject *arg) return PyLong_FromLong(attr); } -PyDoc_STRVAR(pygpu_shader_calc_format_doc, - ".. method:: calc_format()\n" +PyDoc_STRVAR(pygpu_shader_format_calc_doc, + ".. method:: format_calc()\n" "\n" " Build a new format based on the attributes of the shader.\n" "\n" " :return: vertex attribute format for the shader\n" " :rtype: :class:`gpu.types.GPUVertFormat`\n"); -static PyObject *pygpu_shader_calc_format(BPyGPUShader *self, PyObject *UNUSED(arg)) +static PyObject *pygpu_shader_format_calc(BPyGPUShader *self, PyObject *UNUSED(arg)) { BPyGPUVertFormat *ret = (BPyGPUVertFormat *)BPyGPUVertFormat_CreatePyObject(NULL); GPU_vertformat_from_shader(&ret->fmt, self->shader); return (PyObject *)ret; } +PyDoc_STRVAR( + pygpu_shader_attrs_info_get_doc, + ".. method:: attrs_info_get()\n" + "\n" + " Information about the attributes used in the Shader.\n" + "\n" + " :return: tuples containing information about the attributes in order (name, type)\n" + " :rtype: tuple\n"); +static PyObject *pygpu_shader_attrs_info_get(BPyGPUShader *self, PyObject *UNUSED(arg)) +{ + uint attr_len = GPU_shader_get_attribute_len(self->shader); + int location_test = 0, attrs_added = 0; + ; + PyObject *ret = PyTuple_New(attr_len); + while (attrs_added < attr_len) { + char name[256]; + int type; + if (!GPU_shader_get_attribute_info(self->shader, location_test++, name, &type)) { + continue; + } + PyObject *py_type; + if (type != -1) { + py_type = PyUnicode_InternFromString( + PyC_StringEnum_FindIDFromValue(pygpu_attrtype_items, type)); + } + else { + py_type = Py_None; + Py_INCREF(py_type); + } + + PyObject *attr_info = PyTuple_New(2); + PyTuple_SET_ITEMS(attr_info, PyUnicode_FromString(name), py_type); + PyTuple_SetItem(ret, attrs_added, attr_info); + attrs_added++; + } + return ret; +} + static struct PyMethodDef pygpu_shader__tp_methods[] = { {"bind", (PyCFunction)pygpu_shader_bind, METH_NOARGS, pygpu_shader_bind_doc}, {"uniform_from_name", @@ -657,9 +696,13 @@ static struct PyMethodDef pygpu_shader__tp_methods[] = { METH_O, pygpu_shader_attr_from_name_doc}, {"format_calc", - (PyCFunction)pygpu_shader_calc_format, + (PyCFunction)pygpu_shader_format_calc, + METH_NOARGS, + pygpu_shader_format_calc_doc}, + {"attrs_info_get", + (PyCFunction)pygpu_shader_attrs_info_get, METH_NOARGS, - pygpu_shader_calc_format_doc}, + pygpu_shader_attrs_info_get_doc}, {NULL, NULL, 0, NULL}, }; @@ -712,17 +755,17 @@ PyDoc_STRVAR( " ``fragOutput = blender_srgb_to_framebuffer_space(fragOutput)``\n" " to transform the output sRGB colors to the frame-buffer color-space.\n" "\n" - " :param vertexcode: Vertex shader code.\n" + " :arg vertexcode: Vertex shader code.\n" " :type vertexcode: str\n" - " :param fragcode: Fragment shader code.\n" + " :arg fragcode: Fragment shader code.\n" " :type value: str\n" - " :param geocode: Geometry shader code.\n" + " :arg geocode: Geometry shader code.\n" " :type value: str\n" - " :param libcode: Code with functions and presets to be shared between shaders.\n" + " :arg libcode: Code with functions and presets to be shared between shaders.\n" " :type value: str\n" - " :param defines: Preprocessor directives.\n" + " :arg defines: Preprocessor directives.\n" " :type value: str\n" - " :param name: Name of shader code, for debugging purposes.\n" + " :arg name: Name of shader code, for debugging purposes.\n" " :type value: str\n"); PyTypeObject BPyGPUShader_Type = { PyVarObject_HEAD_INIT(NULL, 0).tp_name = "GPUShader", @@ -741,6 +784,24 @@ PyTypeObject BPyGPUShader_Type = { /** \name gpu.shader Module API * \{ */ +static int pyc_parse_buitinshader_w_backward_compatibility(PyObject *o, void *p) +{ + struct PyC_StringEnum *e = p; + const char *value = PyUnicode_AsUTF8(o); + if (value && ELEM(value[0], u'2', u'3')) { + /* Deprecated enums that start with "3D_" or "2D_". */ + value += 3; + for (int i = 0; e->items[i].id; i++) { + if (STREQ(e->items[i].id, value)) { + e->value_found = e->items[i].value; + return 1; + } + } + } + + return PyC_ParseStringEnum(o, p); +} + PyDoc_STRVAR(pygpu_shader_unbind_doc, ".. function:: unbind()\n" "\n" @@ -763,9 +824,9 @@ PyDoc_STRVAR( "``CLIPPED`` value to the config parameter. Note that in this case you also need to " "manually set the value of ``mat4 ModelMatrix``.\n" "\n" - " :param shader_name: One of the builtin shader names.\n" + " :arg shader_name: One of the builtin shader names.\n" " :type shader_name: str\n" - " :param config: One of these types of shader configuration:\n" + " :arg config: One of these types of shader configuration:\n" "\n" " - ``DEFAULT``\n" " - ``CLIPPED``\n" @@ -791,7 +852,7 @@ static PyObject *pygpu_shader_from_builtin(PyObject *UNUSED(self), PyObject *arg if (!_PyArg_ParseTupleAndKeywordsFast(args, kwds, &_parser, - PyC_ParseStringEnum, + pyc_parse_buitinshader_w_backward_compatibility, &pygpu_bultinshader, PyC_ParseStringEnum, &pygpu_config)) { @@ -809,7 +870,7 @@ PyDoc_STRVAR(pygpu_shader_create_from_info_doc, "\n" " Create shader from a GPUShaderCreateInfo.\n" "\n" - " :param shader_info: GPUShaderCreateInfo\n" + " :arg shader_info: GPUShaderCreateInfo\n" " :type shader_info: :class:`bpy.types.GPUShaderCreateInfo`\n" " :return: Shader object corresponding to the given name.\n" " :rtype: :class:`bpy.types.GPUShader`\n"); diff --git a/source/blender/python/gpu/gpu_py_shader.h b/source/blender/python/gpu/gpu_py_shader.h index b5944c4b3a0..ba40636981f 100644 --- a/source/blender/python/gpu/gpu_py_shader.h +++ b/source/blender/python/gpu/gpu_py_shader.h @@ -6,6 +6,10 @@ #pragma once +#ifndef __cplusplus +# include "../generic/py_capi_utils.h" +#endif + /* Make sure that there is always a reference count for PyObjects of type String as the strings are * passed by reference in the #GPUStageInterfaceInfo and #GPUShaderCreateInfo APIs. */ #define USE_GPU_PY_REFERENCES @@ -31,6 +35,7 @@ extern "C" { /* gpu_py_shader_create_info.cc */ +extern const struct PyC_StringEnumItems pygpu_attrtype_items[]; extern PyTypeObject BPyGPUShaderCreateInfo_Type; extern PyTypeObject BPyGPUStageInterfaceInfo_Type; diff --git a/source/blender/python/gpu/gpu_py_shader_create_info.cc b/source/blender/python/gpu/gpu_py_shader_create_info.cc index e00d01174f4..f191e6cc71c 100644 --- a/source/blender/python/gpu/gpu_py_shader_create_info.cc +++ b/source/blender/python/gpu/gpu_py_shader_create_info.cc @@ -58,7 +58,7 @@ static const struct PyC_FlagSet pygpu_qualifiers[] = { " - ``IVEC3``\n" \ " - ``IVEC4``\n" \ " - ``BOOL``\n" -static const struct PyC_StringEnumItems pygpu_attrtype_items[] = { +const struct PyC_StringEnumItems pygpu_attrtype_items[] = { {(int)Type::FLOAT, "FLOAT"}, {(int)Type::VEC2, "VEC2"}, {(int)Type::VEC3, "VEC3"}, @@ -189,11 +189,11 @@ PyDoc_STRVAR(pygpu_interface_info_smooth_doc, "\n" " Add an attribute with qualifier of type `smooth` to the interface block.\n" "\n" - " :param type: One of these types:\n" + " :arg type: One of these types:\n" "\n" PYDOC_TYPE_LIST "\n" " :type type: str\n" - " :param name: name of the attribute.\n" + " :arg name: name of the attribute.\n" " :type name: str\n"); static PyObject *pygpu_interface_info_smooth(BPyGPUStageInterfaceInfo *self, PyObject *args) { @@ -213,11 +213,11 @@ PyDoc_STRVAR(pygpu_interface_info_flat_doc, "\n" " Add an attribute with qualifier of type `flat` to the interface block.\n" "\n" - " :param type: One of these types:\n" + " :arg type: One of these types:\n" "\n" PYDOC_TYPE_LIST "\n" " :type type: str\n" - " :param name: name of the attribute.\n" + " :arg name: name of the attribute.\n" " :type name: str\n"); static PyObject *pygpu_interface_info_flat(BPyGPUStageInterfaceInfo *self, PyObject *args) { @@ -238,11 +238,11 @@ PyDoc_STRVAR( "\n" " Add an attribute with qualifier of type `no_perspective` to the interface block.\n" "\n" - " :param type: One of these types:\n" + " :arg type: One of these types:\n" "\n" PYDOC_TYPE_LIST "\n" " :type type: str\n" - " :param name: name of the attribute.\n" + " :arg name: name of the attribute.\n" " :type name: str\n"); static PyObject *pygpu_interface_info_no_perspective(BPyGPUStageInterfaceInfo *self, PyObject *args) @@ -370,7 +370,7 @@ PyDoc_STRVAR(pygpu_interface_info__tp_doc, "\n" " List of varyings between shader stages.\n\n" "\n" - " :param name: Name of the interface block.\n" + " :arg name: Name of the interface block.\n" " :type value: str\n"); constexpr PyTypeObject pygpu_interface_info_type() { @@ -403,13 +403,13 @@ PyDoc_STRVAR(pygpu_shader_info_vertex_in_doc, "\n" " Add a vertex shader input attribute.\n" "\n" - " :param slot: The attribute index.\n" + " :arg slot: The attribute index.\n" " :type slot: int\n" - " :param type: One of these types:\n" + " :arg type: One of these types:\n" "\n" PYDOC_TYPE_LIST "\n" " :type type: str\n" - " :param name: name of the attribute.\n" + " :arg name: name of the attribute.\n" " :type name: str\n"); static PyObject *pygpu_shader_info_vertex_in(BPyGPUShaderCreateInfo *self, PyObject *args) { @@ -436,7 +436,7 @@ PyDoc_STRVAR(pygpu_shader_info_vertex_out_doc, "\n" " Add a vertex shader output interface block.\n" "\n" - " :param interface: Object describing the block.\n" + " :arg interface: Object describing the block.\n" " :type interface: :class:`gpu.types.GPUStageInterfaceInfo`\n"); static PyObject *pygpu_shader_info_vertex_out(BPyGPUShaderCreateInfo *self, BPyGPUStageInterfaceInfo *o) @@ -462,15 +462,15 @@ PyDoc_STRVAR(pygpu_shader_info_fragment_out_doc, "\n" " Specify a fragment output corresponding to a framebuffer target slot.\n" "\n" - " :param slot: The attribute index.\n" + " :arg slot: The attribute index.\n" " :type slot: int\n" - " :param type: One of these types:\n" + " :arg type: One of these types:\n" "\n" PYDOC_TYPE_LIST "\n" " :type type: str\n" - " :param name: Name of the attribute.\n" + " :arg name: Name of the attribute.\n" " :type name: str\n" - " :param blend: Dual Source Blending Index. It can be 'NONE', 'SRC_0' or 'SRC_1'.\n" + " :arg blend: Dual Source Blending Index. It can be 'NONE', 'SRC_0' or 'SRC_1'.\n" " :type blend: str\n"); static PyObject *pygpu_shader_info_fragment_out(BPyGPUShaderCreateInfo *self, PyObject *args, @@ -521,12 +521,12 @@ PyDoc_STRVAR( "\n" " Specify a uniform variable whose type can be one of those declared in `typedef_source`.\n" "\n" - " :param slot: The uniform variable index.\n" + " :arg slot: The uniform variable index.\n" " :type slot: int\n" - " :param type_name: Name of the data type. It can be a struct type defined in the source " + " :arg type_name: Name of the data type. It can be a struct type defined in the source " "passed through the :meth:`gpu.types.GPUShaderCreateInfo.typedef_source`.\n" " :type type_name: str\n" - " :param name: The uniform variable name.\n" + " :arg name: The uniform variable name.\n" " :type name: str\n"); static PyObject *pygpu_shader_info_uniform_buf(BPyGPUShaderCreateInfo *self, PyObject *args) { @@ -556,19 +556,19 @@ PyDoc_STRVAR( "\n" " Specify an image resource used for arbitrary load and store operations.\n" "\n" - " :param slot: The image resource index.\n" + " :arg slot: The image resource index.\n" " :type slot: int\n" - " :param format: The GPUTexture format that is passed to the shader. Possible values are:\n" + " :arg format: The GPUTexture format that is passed to the shader. Possible values are:\n" "" PYDOC_TEX_FORMAT_ITEMS " :type format: str\n" - " :param type: The data type describing how the image is to be read in the shader. " + " :arg type: The data type describing how the image is to be read in the shader. " "Possible values are:\n" "\n" PYDOC_IMAGE_TYPES "\n" " :type type: str\n" - " :param name: The image resource name.\n" + " :arg name: The image resource name.\n" " :type name: str\n" - " :param qualifiers: Set containing values that describe how the image resource is to be " + " :arg qualifiers: Set containing values that describe how the image resource is to be " "read or written. Possible values are:\n" "" PYDOC_QUALIFIERS "" @@ -636,14 +636,14 @@ PyDoc_STRVAR( "\n" " Specify an image texture sampler.\n" "\n" - " :param slot: The image texture sampler index.\n" + " :arg slot: The image texture sampler index.\n" " :type slot: int\n" - " :param type: The data type describing the format of each sampler unit. Possible values " + " :arg type: The data type describing the format of each sampler unit. Possible values " "are:\n" "\n" PYDOC_IMAGE_TYPES "\n" " :type type: str\n" - " :param name: The image texture sampler name.\n" + " :arg name: The image texture sampler name.\n" " :type name: str\n"); static PyObject *pygpu_shader_info_sampler(BPyGPUShaderCreateInfo *self, PyObject *args) { @@ -673,6 +673,9 @@ static int constant_type_size(Type type) case Type::FLOAT: case Type::INT: case Type::UINT: + case Type::UCHAR4: + case Type::CHAR4: + case blender::gpu::shader::Type::VEC3_101010I2: return 4; break; case Type::VEC2: @@ -695,6 +698,18 @@ static int constant_type_size(Type type) case Type::MAT4: return 64; break; + case blender::gpu::shader::Type::UCHAR: + case blender::gpu::shader::Type::CHAR: + return 1; + break; + case blender::gpu::shader::Type::UCHAR2: + case blender::gpu::shader::Type::CHAR2: + return 2; + break; + case blender::gpu::shader::Type::UCHAR3: + case blender::gpu::shader::Type::CHAR3: + return 3; + break; } BLI_assert(false); return -1; @@ -733,13 +748,13 @@ PyDoc_STRVAR(pygpu_shader_info_push_constant_doc, "\n" " Specify a global access constant.\n" "\n" - " :param type: One of these types:\n" + " :arg type: One of these types:\n" "\n" PYDOC_TYPE_LIST "\n" " :type type: str\n" - " :param name: Name of the constant.\n" + " :arg name: Name of the constant.\n" " :type name: str\n" - " :param size: If not zero, indicates that the constant is an array with the " + " :arg size: If not zero, indicates that the constant is an array with the " "specified size.\n" " :type size: uint\n"); static PyObject *pygpu_shader_info_push_constant(BPyGPUShaderCreateInfo *self, @@ -797,7 +812,7 @@ PyDoc_STRVAR( "\n" " \"void main {gl_Position = vec4(pos, 1.0);}\"\n" "\n" - " :param source: The vertex shader source code.\n" + " :arg source: The vertex shader source code.\n" " :type source: str\n" "\n" " .. seealso:: `GLSL Cross Compilation " @@ -838,7 +853,7 @@ PyDoc_STRVAR( "\n" " \"void main {fragColor = vec4(0.0, 0.0, 0.0, 1.0);}\"\n" "\n" - " :param source: The fragment shader source code.\n" + " :arg source: The fragment shader source code.\n" " :type source: str\n" "\n" " .. seealso:: `GLSL Cross Compilation " @@ -879,7 +894,7 @@ PyDoc_STRVAR(pygpu_shader_info_typedef_source_doc, "\n" " \"struct MyType {int foo; float bar;};\"\n" "\n" - " :param source: The source code defining types.\n" + " :arg source: The source code defining types.\n" " :type source: str\n"); static PyObject *pygpu_shader_info_typedef_source(BPyGPUShaderCreateInfo *self, PyObject *o) { @@ -918,9 +933,9 @@ PyDoc_STRVAR(pygpu_shader_info_define_doc, "\n" " #define name value\n" "\n" - " :param name: Token name.\n" + " :arg name: Token name.\n" " :type name: str\n" - " :param value: Text that replaces token occurrences.\n" + " :arg value: Text that replaces token occurrences.\n" " :type value: str\n"); static PyObject *pygpu_shader_info_define(BPyGPUShaderCreateInfo *self, PyObject *args) { @@ -999,7 +1014,7 @@ static struct PyMethodDef pygpu_shader_info__tp_methods[] = { /** \} */ /* -------------------------------------------------------------------- */ -/** \name GPUShaderCreateInfo Init +/** \name GPUShaderCreateInfo Initialization * \{ */ static PyObject *pygpu_shader_info__tp_new(PyTypeObject *UNUSED(type), diff --git a/source/blender/python/gpu/gpu_py_state.c b/source/blender/python/gpu/gpu_py_state.c index fb69bb316c4..35ecc2aff40 100644 --- a/source/blender/python/gpu/gpu_py_state.c +++ b/source/blender/python/gpu/gpu_py_state.c @@ -72,7 +72,7 @@ PyDoc_STRVAR( "\n" " Defines the fixed pipeline blending equation.\n" "\n" - " :param mode: The type of blend mode.\n" + " :arg mode: The type of blend mode.\n" " * ``NONE`` No blending.\n" " * ``ALPHA`` The original color channels are interpolated according to the alpha " "value.\n" @@ -114,7 +114,7 @@ PyDoc_STRVAR(pygpu_state_clip_distances_set_doc, "\n" " Sets the number of `gl_ClipDistance` planes used for clip geometry.\n" "\n" - " :param distances_enabled: Number of clip distances enabled.\n" + " :arg distances_enabled: Number of clip distances enabled.\n" " :type distances_enabled: int\n"); static PyObject *pygpu_state_clip_distances_set(PyObject *UNUSED(self), PyObject *value) { @@ -136,7 +136,7 @@ PyDoc_STRVAR(pygpu_state_depth_test_set_doc, "\n" " Defines the depth_test equation.\n" "\n" - " :param mode: The depth test equation name.\n" + " :arg mode: The depth test equation name.\n" " Possible values are `NONE`, `ALWAYS`, `LESS`, `LESS_EQUAL`, `EQUAL`, " "`GREATER` and `GREATER_EQUAL`.\n" " :type mode: str\n"); @@ -166,7 +166,7 @@ PyDoc_STRVAR(pygpu_state_depth_mask_set_doc, "\n" " Write to depth component.\n" "\n" - " :param value: True for writing to the depth component.\n" + " :arg value: True for writing to the depth component.\n" " :type near: bool\n"); static PyObject *pygpu_state_depth_mask_set(PyObject *UNUSED(self), PyObject *value) { @@ -193,9 +193,10 @@ PyDoc_STRVAR(pygpu_state_viewport_set_doc, " Specifies the viewport of the active framebuffer.\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 width, height: width and height of the viewport_set.\n" - " :type x, y, xsize, ysize: int\n"); + " :arg x, y: lower left corner of the viewport_set rectangle, in pixels.\n" + " :type x, y: int\n" + " :arg xsize, ysize: width and height of the viewport_set.\n" + " :type xsize, ysize: int\n"); static PyObject *pygpu_state_viewport_set(PyObject *UNUSED(self), PyObject *args) { int x, y, xsize, ysize; @@ -230,7 +231,7 @@ PyDoc_STRVAR(pygpu_state_line_width_set_doc, "\n" " Specify the width of rasterized lines.\n" "\n" - " :param size: New width.\n" + " :arg size: New width.\n" " :type mode: float\n"); static PyObject *pygpu_state_line_width_set(PyObject *UNUSED(self), PyObject *value) { @@ -258,7 +259,7 @@ PyDoc_STRVAR(pygpu_state_point_size_set_doc, "\n" " Specify the diameter of rasterized points.\n" "\n" - " :param size: New diameter.\n" + " :arg size: New diameter.\n" " :type mode: float\n"); static PyObject *pygpu_state_point_size_set(PyObject *UNUSED(self), PyObject *value) { @@ -276,7 +277,7 @@ PyDoc_STRVAR(pygpu_state_color_mask_set_doc, "\n" " Enable or disable writing of frame buffer color components.\n" "\n" - " :param r, g, b, a: components red, green, blue, and alpha.\n" + " :arg r, g, b, a: components red, green, blue, and alpha.\n" " :type r, g, b, a: bool\n"); static PyObject *pygpu_state_color_mask_set(PyObject *UNUSED(self), PyObject *args) { @@ -294,7 +295,7 @@ PyDoc_STRVAR(pygpu_state_face_culling_set_doc, "\n" " Specify whether none, front-facing or back-facing facets can be culled.\n" "\n" - " :param mode: `NONE`, `FRONT` or `BACK`.\n" + " :arg mode: `NONE`, `FRONT` or `BACK`.\n" " :type mode: str\n"); static PyObject *pygpu_state_face_culling_set(PyObject *UNUSED(self), PyObject *value) { @@ -312,7 +313,7 @@ PyDoc_STRVAR(pygpu_state_front_facing_set_doc, "\n" " Specifies the orientation of front-facing polygons.\n" "\n" - " :param invert: True for clockwise polygons as front-facing.\n" + " :arg invert: True for clockwise polygons as front-facing.\n" " :type mode: bool\n"); static PyObject *pygpu_state_front_facing_set(PyObject *UNUSED(self), PyObject *value) { @@ -331,7 +332,7 @@ PyDoc_STRVAR(pygpu_state_program_point_size_set_doc, " If enabled, the derived point size is taken from the (potentially clipped) " "shader builtin gl_PointSize.\n" "\n" - " :param enable: True for shader builtin gl_PointSize.\n" + " :arg enable: True for shader builtin gl_PointSize.\n" " :type enable: bool\n"); static PyObject *pygpu_state_program_point_size_set(PyObject *UNUSED(self), PyObject *value) { diff --git a/source/blender/python/gpu/gpu_py_texture.c b/source/blender/python/gpu/gpu_py_texture.c index 7a23f7ac91f..ae004341304 100644 --- a/source/blender/python/gpu/gpu_py_texture.c +++ b/source/blender/python/gpu/gpu_py_texture.c @@ -280,9 +280,9 @@ PyDoc_STRVAR( "\n" " Fill texture with specific value.\n" "\n" - " :param format: The format that describes the content of a single item.\n" + " :arg format: The format that describes the content of a single item.\n" " Possible values are `FLOAT`, `INT`, `UINT`, `UBYTE`, `UINT_24_8` and `10_11_11_REV`.\n" - " :type type: str\n" + " :type format: str\n" " :arg value: sequence each representing the value to fill.\n" " :type value: sequence of 1, 2, 3 or 4 values\n"); static PyObject *pygpu_texture_clear(BPyGPUTexture *self, PyObject *args, PyObject *kwds) diff --git a/source/blender/python/gpu/gpu_py_vertex_buffer.c b/source/blender/python/gpu/gpu_py_vertex_buffer.c index ab2ff59a689..fd36c0a2d71 100644 --- a/source/blender/python/gpu/gpu_py_vertex_buffer.c +++ b/source/blender/python/gpu/gpu_py_vertex_buffer.c @@ -261,9 +261,9 @@ PyDoc_STRVAR(pygpu_vertbuf_attr_fill_doc, "\n" " Insert data into the buffer for a single attribute.\n" "\n" - " :param id: Either the name or the id of the attribute.\n" + " :arg id: Either the name or the id of the attribute.\n" " :type id: int or str\n" - " :param data: Sequence of data that should be stored in the buffer\n" + " :arg data: Sequence of data that should be stored in the buffer\n" " :type data: sequence of floats, ints, vectors or matrices\n"); static PyObject *pygpu_vertbuf_attr_fill(BPyGPUVertBuf *self, PyObject *args, PyObject *kwds) { @@ -327,10 +327,10 @@ PyDoc_STRVAR(pygpu_vertbuf__tp_doc, "\n" " Contains a VBO.\n" "\n" - " :param format: Vertex format.\n" - " :type buf: :class:`gpu.types.GPUVertFormat`\n" - " :param len: Amount of vertices that will fit into this buffer.\n" - " :type type: `int`\n"); + " :arg format: Vertex format.\n" + " :type format: :class:`gpu.types.GPUVertFormat`\n" + " :arg len: Amount of vertices that will fit into this buffer.\n" + " :type len: int\n"); PyTypeObject BPyGPUVertBuf_Type = { PyVarObject_HEAD_INIT(NULL, 0).tp_name = "GPUVertBuf", .tp_basicsize = sizeof(BPyGPUVertBuf), diff --git a/source/blender/python/gpu/gpu_py_vertex_format.c b/source/blender/python/gpu/gpu_py_vertex_format.c index 40a0e5d1e9f..ac0ec6bdc01 100644 --- a/source/blender/python/gpu/gpu_py_vertex_format.c +++ b/source/blender/python/gpu/gpu_py_vertex_format.c @@ -63,15 +63,15 @@ PyDoc_STRVAR( "\n" " Add a new attribute to the format.\n" "\n" - " :param id: Name the attribute. Often `position`, `normal`, ...\n" + " :arg id: Name the attribute. Often `position`, `normal`, ...\n" " :type id: str\n" - " :param comp_type: The data type that will be used store the value in memory.\n" + " :arg comp_type: The data type that will be used store the value in memory.\n" " Possible values are `I8`, `U8`, `I16`, `U16`, `I32`, `U32`, `F32` and `I10`.\n" " :type comp_type: str\n" - " :param len: How many individual values the attribute consists of\n" + " :arg len: How many individual values the attribute consists of\n" " (e.g. 2 for uv coordinates).\n" " :type len: int\n" - " :param fetch_mode: How values from memory will be converted when used in the shader.\n" + " :arg fetch_mode: How values from memory will be converted when used in the shader.\n" " This is mainly useful for memory optimizations when you want to store values with\n" " reduced precision. E.g. you can store a float in only 1 byte but it will be\n" " converted to a normal 4 byte float when used.\n" diff --git a/source/blender/python/intern/bpy.c b/source/blender/python/intern/bpy.c index 7fe0b9455e6..3b3ffb321c3 100644 --- a/source/blender/python/intern/bpy.c +++ b/source/blender/python/intern/bpy.c @@ -655,7 +655,7 @@ void BPy_init_modules(struct bContext *C) PyModule_AddObject(mod, m->ml_name, (PyObject *)PyCFunction_New(m, NULL)); } - /* register funcs (bpy_rna.c) */ + /* Register functions (`bpy_rna.c`). */ PyModule_AddObject(mod, meth_bpy_register_class.ml_name, (PyObject *)PyCFunction_New(&meth_bpy_register_class, NULL)); diff --git a/source/blender/python/intern/bpy.h b/source/blender/python/intern/bpy.h index 313385b7f5d..f62542bb342 100644 --- a/source/blender/python/intern/bpy.h +++ b/source/blender/python/intern/bpy.h @@ -12,7 +12,7 @@ extern "C" { struct bContext; -/** Creates the bpy module and adds it to `sys.modules` for importing. */ +/** Creates the `bpy` module and adds it to `sys.modules` for importing. */ void BPy_init_modules(struct bContext *C); extern PyObject *bpy_package_py; diff --git a/source/blender/python/intern/bpy_app.c b/source/blender/python/intern/bpy_app.c index 939473ceaa0..70cf231bc26 100644 --- a/source/blender/python/intern/bpy_app.c +++ b/source/blender/python/intern/bpy_app.c @@ -79,8 +79,6 @@ static PyStructSequence_Field app_info_fields[] = { {"version_string", "The Blender version formatted as a string"}, {"version_cycle", "The release status of this build alpha/beta/rc/release"}, {"version_char", "Deprecated, always an empty string"}, - {"binary_path", - "The location of Blender's executable, useful for utilities that open new instances"}, {"background", "Boolean, True when blender is running without a user interface (started with -b)"}, {"factory_startup", "Boolean, True when blender is running with --factory-startup)"}, @@ -151,7 +149,6 @@ static PyObject *make_app_info(void) SetStrItem(STRINGIFY(BLENDER_VERSION_CYCLE)); SetStrItem(""); - SetStrItem(BKE_appdir_program_path()); SetObjItem(PyBool_FromLong(G.background)); SetObjItem(PyBool_FromLong(G.factory_startup)); @@ -345,6 +342,33 @@ static PyObject *bpy_app_autoexec_fail_message_get(PyObject *UNUSED(self), void return PyC_UnicodeFromByte(G.autoexec_fail); } +PyDoc_STRVAR(bpy_app_binary_path_doc, + "The location of Blender's executable, useful for utilities that open new instances. " + "Read-only unless Blender is built as a Python module - in this case the value is " + "an empty string which script authors may point to a Blender binary."); +static PyObject *bpy_app_binary_path_get(PyObject *UNUSED(self), void *UNUSED(closure)) +{ + return PyC_UnicodeFromByte(BKE_appdir_program_path()); +} + +static int bpy_app_binary_path_set(PyObject *UNUSED(self), PyObject *value, void *UNUSED(closure)) +{ +#ifndef WITH_PYTHON_MODULE + PyErr_SetString(PyExc_AttributeError, + "bpy.app.binary_path is only writable when built as a Python module"); + return -1; +#endif + PyObject *value_coerce = NULL; + const char *filepath = PyC_UnicodeAsByte(value, &value_coerce); + if (filepath == NULL) { + PyErr_Format(PyExc_ValueError, "expected a string or bytes, got %s", Py_TYPE(value)->tp_name); + return -1; + } + BKE_appdir_program_path_init(filepath); + Py_XDECREF(value_coerce); + return 0; +} + static PyGetSetDef bpy_app_getsets[] = { {"debug", bpy_app_debug_get, bpy_app_debug_set, bpy_app_debug_doc, (void *)G_DEBUG}, {"debug_ffmpeg", @@ -450,7 +474,14 @@ static PyGetSetDef bpy_app_getsets[] = { (void *)G_FLAG_SCRIPT_AUTOEXEC_FAIL_QUIET}, {"autoexec_fail_message", bpy_app_autoexec_fail_message_get, NULL, NULL, NULL}, - /* End-of-list marker. */ + /* Support script authors setting the Blender binary path to use, otherwise this value + * is not known when built as a Python module. */ + {"binary_path", + bpy_app_binary_path_get, + bpy_app_binary_path_set, + bpy_app_binary_path_doc, + NULL}, + {NULL, NULL, NULL, NULL, NULL}, }; @@ -528,7 +559,7 @@ PyObject *BPY_app_struct(void) BlenderAppType.tp_hash = (hashfunc) _Py_HashPointer; /* without this we can't do set(sys.modules) T29635. */ - /* kindof a hack ontop of PyStructSequence */ + /* Kind of a hack on top of #PyStructSequence. */ py_struct_seq_getset_init(); py_struct_seq_method_init(); diff --git a/source/blender/python/intern/bpy_app_icons.c b/source/blender/python/intern/bpy_app_icons.c index 3f884338bbb..918d96d9f44 100644 --- a/source/blender/python/intern/bpy_app_icons.c +++ b/source/blender/python/intern/bpy_app_icons.c @@ -166,7 +166,7 @@ static struct PyModuleDef M_AppIcons_module_def = { NULL, /* m_doc */ 0, /* m_size */ M_AppIcons_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/intern/bpy_app_timers.c b/source/blender/python/intern/bpy_app_timers.c index 5a42ecfdbc8..4adc200357b 100644 --- a/source/blender/python/intern/bpy_app_timers.c +++ b/source/blender/python/intern/bpy_app_timers.c @@ -168,7 +168,7 @@ static struct PyModuleDef M_AppTimers_module_def = { NULL, /* m_doc */ 0, /* m_size */ M_AppTimers_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/intern/bpy_gizmo_wrap.c b/source/blender/python/intern/bpy_gizmo_wrap.c index ad235e691c4..99720e7a1ba 100644 --- a/source/blender/python/intern/bpy_gizmo_wrap.c +++ b/source/blender/python/intern/bpy_gizmo_wrap.c @@ -150,7 +150,7 @@ void BPY_RNA_gizmo_wrapper(wmGizmoType *gzt, void *userdata) /* don't do translations here yet */ #if 0 - /* Use i18n context from rna_ext.srna if possible (py gizmogroups). */ + /* Use i18n context from rna_ext.srna if possible (py gizmo-groups). */ if (gt->rna_ext.srna) { RNA_def_struct_translation_context(gt->srna, RNA_struct_translation_context(gt->rna_ext.srna)); } diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c index 939fa475344..3a095f4b9f3 100644 --- a/source/blender/python/intern/bpy_interface.c +++ b/source/blender/python/intern/bpy_interface.c @@ -11,6 +11,10 @@ #include <Python.h> #include <frameobject.h> +#ifdef WITH_PYTHON_MODULE +# include "pylifecycle.h" /* For `Py_Version`. */ +#endif + #include "MEM_guardedalloc.h" #include "CLG_log.h" @@ -585,6 +589,11 @@ void BPY_python_use_system_env(void) void BPY_python_backtrace(FILE *fp) { fputs("\n# Python backtrace\n", fp); + + /* Can happen in rare cases. */ + if (!_PyThreadState_UncheckedGet()) { + return; + } PyFrameObject *frame; if (!(frame = PyEval_GetFrame())) { return; @@ -763,7 +772,7 @@ static struct PyModuleDef bpy_proxy_def = { NULL, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ bpy_module_free, /* m_free */ @@ -802,6 +811,50 @@ static void bpy_module_delay_init(PyObject *bpy_proxy) PyDict_Update(PyModule_GetDict(bpy_proxy), PyModule_GetDict(bpy_package_py)); } +/** + * Raise an error and return false if the Python version used to compile Blender + * isn't compatible with the interpreter loading the `bpy` module. + */ +static bool bpy_module_ensure_compatible_version(void) +{ + /* First check the Python version used matches the major version that Blender was built with. + * While this isn't essential, the error message in this case may be cryptic and misleading. + * NOTE: using `Py_LIMITED_API` would remove the need for this, in practice it's + * unlikely Blender will ever used the limited API though. */ +# if PY_VERSION_HEX >= 0x030b0000 /* Python 3.11 & newer. */ + const uint version_runtime = Py_Version; +# else + uint version_runtime; + { + uint version_runtime_major = 0, version_runtime_minor = 0; + const char *version_str = Py_GetVersion(); + if (sscanf(version_str, "%u.%u.", &version_runtime_major, &version_runtime_minor) != 2) { + /* Should never happen, raise an error to ensure this check never fails silently. */ + PyErr_Format(PyExc_ImportError, "Failed to extract the version from \"%s\"", version_str); + return false; + } + version_runtime = (version_runtime_major << 24) | (version_runtime_minor << 16); + } +# endif + + uint version_compile_major = PY_VERSION_HEX >> 24; + uint version_compile_minor = ((PY_VERSION_HEX & 0x00ff0000) >> 16); + uint version_runtime_major = version_runtime >> 24; + uint version_runtime_minor = ((version_runtime & 0x00ff0000) >> 16); + if ((version_compile_major != version_runtime_major) || + (version_compile_minor != version_runtime_minor)) { + PyErr_Format(PyExc_ImportError, + "The version of \"bpy\" was compiled with: " + "(%u.%u) is incompatible with: (%u.%u) used by the interpreter!", + version_compile_major, + version_compile_minor, + version_runtime_major, + version_runtime_minor); + return false; + } + return true; +} + static void dealloc_obj_dealloc(PyObject *self); static PyTypeObject dealloc_obj_Type; @@ -819,6 +872,10 @@ PyMODINIT_FUNC PyInit_bpy(void); PyMODINIT_FUNC PyInit_bpy(void) { + if (!bpy_module_ensure_compatible_version()) { + return NULL; /* The error has been set. */ + } + PyObject *bpy_proxy = PyModule_Create(&bpy_proxy_def); /* Problem: diff --git a/source/blender/python/intern/bpy_library_load.c b/source/blender/python/intern/bpy_library_load.c index 9754599eeed..f29a8d34359 100644 --- a/source/blender/python/intern/bpy_library_load.c +++ b/source/blender/python/intern/bpy_library_load.c @@ -108,7 +108,7 @@ static PyTypeObject bpy_lib_Type = { NULL, /* ternaryfunc tp_call; */ NULL, /* reprfunc tp_str; */ - /* will only use these if this is a subtype of a py class */ + /* Will only use these if this is a sub-type of a Python class. */ PyObject_GenericGetAttr, /* getattrofunc tp_getattro; */ NULL, /* setattrofunc tp_setattro; */ diff --git a/source/blender/python/intern/bpy_operator.c b/source/blender/python/intern/bpy_operator.c index 95879b02295..2db8c08cfd4 100644 --- a/source/blender/python/intern/bpy_operator.c +++ b/source/blender/python/intern/bpy_operator.c @@ -289,7 +289,7 @@ static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args) reports = MEM_mallocN(sizeof(ReportList), "wmOperatorReportList"); /* Own so these don't move into global reports. */ - BKE_reports_init(reports, RPT_STORE | RPT_OP_HOLD); + BKE_reports_init(reports, RPT_STORE | RPT_OP_HOLD | RPT_PRINT_HANDLED_BY_OWNER); #ifdef BPY_RELEASE_GIL /* release GIL, since a thread could be started from an operator diff --git a/source/blender/python/intern/bpy_path.c b/source/blender/python/intern/bpy_path.c index fbb47817389..f3a1a7cb1df 100644 --- a/source/blender/python/intern/bpy_path.c +++ b/source/blender/python/intern/bpy_path.c @@ -26,7 +26,7 @@ static struct PyModuleDef _bpy_path_module_def = { NULL, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c index 179a0250688..07ce44f5f3b 100644 --- a/source/blender/python/intern/bpy_rna.c +++ b/source/blender/python/intern/bpy_rna.c @@ -1397,7 +1397,7 @@ PyObject *pyrna_prop_to_py(PointerRNA *ptr, PropertyRNA *prop) buf = RNA_property_string_get_alloc(ptr, prop, buf_fixed, sizeof(buf_fixed), &buf_len); #ifdef USE_STRING_COERCE - /* Only file paths get special treatment, they may contain non utf-8 chars. */ + /* Only file paths get special treatment, they may contain non UTF-8 chars. */ if (subtype == PROP_BYTESTRING) { ret = PyBytes_FromStringAndSize(buf, buf_len); } @@ -2213,6 +2213,26 @@ static int pyrna_prop_collection_bool(BPy_PropertyRNA *self) } \ (void)0 +/** + * \param result: The result of calling a subscription operation on a collection (never NULL). + */ +static int pyrna_prop_collection_subscript_is_valid_or_error(const PyObject *value) +{ + if (value != Py_None) { + BLI_assert(BPy_StructRNA_Check(value)); + const BPy_StructRNA *value_pyrna = (const BPy_StructRNA *)value; + if (UNLIKELY(value_pyrna->ptr.type == NULL)) { + /* It's important to use a `TypeError` as that is what's returned when `__getitem__` is + * called on an object that doesn't support item access. */ + PyErr_Format(PyExc_TypeError, + "'%.200s' object is not subscriptable (only iteration is supported)", + Py_TYPE(value)->tp_name); + return -1; + } + } + return 0; +} + /* Internal use only. */ static PyObject *pyrna_prop_collection_subscript_int(BPy_PropertyRNA *self, Py_ssize_t keynum) { @@ -2223,8 +2243,35 @@ static PyObject *pyrna_prop_collection_subscript_int(BPy_PropertyRNA *self, Py_s PYRNA_PROP_COLLECTION_ABS_INDEX(NULL); - if (RNA_property_collection_lookup_int(&self->ptr, self->prop, keynum_abs, &newptr)) { - return pyrna_struct_CreatePyObject(&newptr); + if (RNA_property_collection_lookup_int_has_fn(self->prop)) { + if (RNA_property_collection_lookup_int(&self->ptr, self->prop, keynum_abs, &newptr)) { + return pyrna_struct_CreatePyObject(&newptr); + } + } + else { + /* No callback defined, just iterate and find the nth item. */ + const int key = (int)keynum_abs; + PyObject *result = NULL; + bool found = false; + CollectionPropertyIterator iter; + RNA_property_collection_begin(&self->ptr, self->prop, &iter); + for (int i = 0; iter.valid; RNA_property_collection_next(&iter), i++) { + if (i == key) { + result = pyrna_struct_CreatePyObject(&iter.ptr); + found = true; + break; + } + } + /* It's important to end the iterator after `result` has been created + * so iterators may optionally invalidate items that were iterated over, see: T100286. */ + RNA_property_collection_end(&iter); + if (found) { + if (result && (pyrna_prop_collection_subscript_is_valid_or_error(result) == -1)) { + Py_DECREF(result); + result = NULL; /* The exception has been set. */ + } + return result; + } } const int len = RNA_property_collection_length(&self->ptr, self->prop); @@ -2306,8 +2353,45 @@ static PyObject *pyrna_prop_collection_subscript_str(BPy_PropertyRNA *self, cons PYRNA_PROP_CHECK_OBJ(self); - if (RNA_property_collection_lookup_string(&self->ptr, self->prop, keyname, &newptr)) { - return pyrna_struct_CreatePyObject(&newptr); + if (RNA_property_collection_lookup_string_has_fn(self->prop)) { + if (RNA_property_collection_lookup_string(&self->ptr, self->prop, keyname, &newptr)) { + return pyrna_struct_CreatePyObject(&newptr); + } + } + else { + /* No callback defined, just iterate and find the nth item. */ + const int keylen = strlen(keyname); + char name[256]; + int namelen; + PyObject *result = NULL; + bool found = false; + CollectionPropertyIterator iter; + RNA_property_collection_begin(&self->ptr, self->prop, &iter); + for (int i = 0; iter.valid; RNA_property_collection_next(&iter), i++) { + PropertyRNA *nameprop = RNA_struct_name_property(iter.ptr.type); + char *nameptr = RNA_property_string_get_alloc( + &iter.ptr, nameprop, name, sizeof(name), &namelen); + if ((keylen == namelen) && STREQ(nameptr, keyname)) { + found = true; + } + if ((char *)&name != nameptr) { + MEM_freeN(nameptr); + } + if (found) { + result = pyrna_struct_CreatePyObject(&iter.ptr); + break; + } + } + /* It's important to end the iterator after `result` has been created + * so iterators may optionally invalidate items that were iterated over, see: T100286. */ + RNA_property_collection_end(&iter); + if (found) { + if (result && (pyrna_prop_collection_subscript_is_valid_or_error(result) == -1)) { + Py_DECREF(result); + result = NULL; /* The exception has been set. */ + } + return result; + } } PyErr_Format(PyExc_KeyError, "bpy_prop_collection[key]: key \"%.200s\" not found", keyname); @@ -3990,7 +4074,7 @@ static void pyrna_dir_members_rna(PyObject *list, PointerRNA *ptr) { const char *idname; - /* For looping over attrs and funcs. */ + /* For looping over attributes and functions. */ PointerRNA tptr; PropertyRNA *iterprop; @@ -5853,7 +5937,7 @@ static PyObject *pyrna_param_to_py(PointerRNA *ptr, PropertyRNA *prop, void *dat len = RNA_property_array_length(ptr, prop); } - /* Resolve the array from a new pytype. */ + /* Resolve the array from a new Python type. */ /* TODO(Kazanbas): make multi-dimensional sequences here. */ @@ -6403,7 +6487,7 @@ static PyObject *pyrna_func_doc_get(BPy_FunctionRNA *self, void *UNUSED(closure) PyTypeObject pyrna_struct_meta_idprop_Type = { PyVarObject_HEAD_INIT(NULL, 0) "bpy_struct_meta_idprop", /* tp_name */ - /* NOTE: would be PyTypeObject, but subtypes of Type must be PyHeapTypeObject's. */ + /* NOTE: would be PyTypeObject, but sub-types of Type must be PyHeapTypeObject's. */ sizeof(PyHeapTypeObject), /* tp_basicsize */ 0, /* tp_itemsize */ @@ -7224,7 +7308,7 @@ static PyObject *pyrna_srna_PyBase(StructRNA *srna) //, PyObject *bpy_types_dic if (base && base != srna) { // printf("debug subtype %s %p\n", RNA_struct_identifier(srna), srna); py_base = pyrna_srna_Subtype(base); //, bpy_types_dict); - Py_DECREF(py_base); /* Srna owns, this is only to pass as an arg. */ + Py_DECREF(py_base); /* `srna` owns, this is only to pass as an argument. */ } if (py_base == NULL) { @@ -7784,7 +7868,7 @@ static struct PyModuleDef bpy_types_module_def = { bpy_types_module_doc, /* m_doc */ sizeof(struct BPy_TypesModule_State), /* m_size */ bpy_types_module_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ @@ -8651,10 +8735,10 @@ static int bpy_class_call(bContext *C, PointerRNA *ptr, FunctionRNA *func, Param else if (ret_len == 1) { err = pyrna_py_to_prop(&funcptr, pret_single, retdata_single, ret, ""); - /* when calling operator funcs only gives Function.result with - * no line number since the func has finished calling on error, - * re-raise the exception with more info since it would be slow to - * create prefix on every call (when there are no errors) */ + /* When calling operator functions only gives `Function.result` with no line number + * since the function has finished calling on error, re-raise the exception with more + * information since it would be slow to create prefix on every call + * (when there are no errors). */ if (err == -1) { PyC_Err_Format_Prefix(PyExc_RuntimeError, "class %.200s, function %.200s: incompatible return value ", @@ -8762,7 +8846,7 @@ static void bpy_class_free(void *pyob_ptr) } /** - * \note This isn't essential to run on startup, since subtypes will lazy initialize. + * \note This isn't essential to run on startup, since sub-types will lazy initialize. * But keep running in debug mode so we get immediate notification of bad class hierarchy * or any errors in "bpy_types.py" at load time, so errors don't go unnoticed. */ diff --git a/source/blender/python/intern/bpy_rna.h b/source/blender/python/intern/bpy_rna.h index 91fa0ea2c8d..d7778da6213 100644 --- a/source/blender/python/intern/bpy_rna.h +++ b/source/blender/python/intern/bpy_rna.h @@ -218,11 +218,13 @@ void pyrna_struct_type_extend_capi(struct StructRNA *srna, struct PyMethodDef *py_method, struct PyGetSetDef *py_getset); -/* called before stopping python */ +/* Called before stopping Python. */ + void pyrna_alloc_types(void); void pyrna_free_types(void); -/* primitive type conversion */ +/* Primitive type conversion. */ + int pyrna_py_to_array( PointerRNA *ptr, PropertyRNA *prop, char *param_data, PyObject *py, const char *error_prefix); int pyrna_py_to_array_index(PointerRNA *ptr, diff --git a/source/blender/python/intern/bpy_rna_array.c b/source/blender/python/intern/bpy_rna_array.c index 8506ec97bc3..48ba028edf0 100644 --- a/source/blender/python/intern/bpy_rna_array.c +++ b/source/blender/python/intern/bpy_rna_array.c @@ -927,7 +927,7 @@ PyObject *pyrna_py_from_array_index(BPy_PropertyArrayRNA *self, /* just in case check */ len = RNA_property_multi_array_length(ptr, prop, arraydim); if (index >= len || index < 0) { - /* this shouldn't happen because higher level funcs must check for invalid index */ + /* This shouldn't happen because higher level functions must check for invalid index. */ CLOG_WARN(BPY_LOG_RNA, "invalid index %d for array with length=%d", index, len); PyErr_SetString(PyExc_IndexError, "out of range"); diff --git a/source/blender/python/intern/bpy_rna_data.c b/source/blender/python/intern/bpy_rna_data.c index cc0b4aa57d5..a3e865f4846 100644 --- a/source/blender/python/intern/bpy_rna_data.c +++ b/source/blender/python/intern/bpy_rna_data.c @@ -86,7 +86,7 @@ static PyTypeObject bpy_rna_data_context_Type = { NULL, /* ternaryfunc tp_call; */ NULL, /* reprfunc tp_str; */ - /* will only use these if this is a subtype of a py class */ + /* Will only use these if this is a sub-type of a Python class. */ NULL, /* getattrofunc tp_getattro; */ NULL, /* setattrofunc tp_setattro; */ diff --git a/source/blender/python/intern/bpy_rna_operator.c b/source/blender/python/intern/bpy_rna_operator.c index fd6cc93ed32..e0a4356dc18 100644 --- a/source/blender/python/intern/bpy_rna_operator.c +++ b/source/blender/python/intern/bpy_rna_operator.c @@ -84,7 +84,7 @@ PyDoc_STRVAR(BPY_rna_operator_poll_message_set_doc, " When message is callable, " "additional user defined positional arguments are passed to the message function.\n" "\n" - " :param message: The message or a function that returns the message.\n" + " :arg message: The message or a function that returns the message.\n" " :type message: string or a callable that returns a string or None.\n"); static PyObject *BPY_rna_operator_poll_message_set(PyObject *UNUSED(self), PyObject *args) diff --git a/source/blender/python/intern/bpy_rna_types_capi.c b/source/blender/python/intern/bpy_rna_types_capi.c index c3a07847aff..2b830eb9ffe 100644 --- a/source/blender/python/intern/bpy_rna_types_capi.c +++ b/source/blender/python/intern/bpy_rna_types_capi.c @@ -185,16 +185,16 @@ PyDoc_STRVAR( " It will be called every time the specified region in the space type will be drawn.\n" " Note: All arguments are positional only for now.\n" "\n" - " :param callback:\n" + " :arg callback:\n" " A function that will be called when the region is drawn.\n" " It gets the specified arguments as input.\n" " :type callback: function\n" - " :param args: Arguments that will be passed to the callback.\n" + " :arg args: Arguments that will be passed to the callback.\n" " :type args: tuple\n" - " :param region_type: The region type the callback draws in; usually ``WINDOW``. " + " :arg region_type: The region type the callback draws in; usually ``WINDOW``. " "(:class:`bpy.types.Region.type`)\n" " :type region_type: str\n" - " :param draw_type: Usually ``POST_PIXEL`` for 2D drawing and ``POST_VIEW`` for 3D drawing. " + " :arg draw_type: Usually ``POST_PIXEL`` for 2D drawing and ``POST_VIEW`` for 3D drawing. " "In some cases ``PRE_VIEW`` can be used. ``BACKDROP`` can be used for backdrops in the node " "editor.\n" " :type draw_type: str\n" @@ -206,9 +206,9 @@ PyDoc_STRVAR(pyrna_draw_handler_remove_doc, "\n" " Remove a draw handler that was added previously.\n" "\n" - " :param handler: The draw handler that should be removed.\n" + " :arg handler: The draw handler that should be removed.\n" " :type handler: object\n" - " :param region_type: Region type the callback was added to.\n" + " :arg region_type: Region type the callback was added to.\n" " :type region_type: str\n"); static struct PyMethodDef pyrna_space_methods[] = { diff --git a/source/blender/python/intern/bpy_traceback.c b/source/blender/python/intern/bpy_traceback.c index 1f2458c752f..428263fd4c4 100644 --- a/source/blender/python/intern/bpy_traceback.c +++ b/source/blender/python/intern/bpy_traceback.c @@ -25,7 +25,7 @@ static const char *traceback_filepath(PyTracebackObject *tb, PyObject **coerce) return PyBytes_AS_STRING(*coerce); } -/* copied from pythonrun.c, 3.10.0 */ +/* Copied from `pythonrun.c`, 3.10.0 */ _Py_static_string(PyId_string, "<string>"); static int parse_syntax_error(PyObject *err, diff --git a/source/blender/python/intern/bpy_utils_units.c b/source/blender/python/intern/bpy_utils_units.c index 1e5856a3285..075a68f31f9 100644 --- a/source/blender/python/intern/bpy_utils_units.c +++ b/source/blender/python/intern/bpy_utils_units.c @@ -90,7 +90,7 @@ static PyObject *py_structseq_from_strings(PyTypeObject *py_type, const char **str_iter; PyStructSequence_Field *desc; - /* initialize array */ + /* Initialize array. */ /* We really populate the contexts' fields here! */ for (str_iter = str_items, desc = py_sseq_desc->fields; *str_iter; str_iter++, desc++) { desc->name = (char *)*str_iter; @@ -101,7 +101,7 @@ static PyObject *py_structseq_from_strings(PyTypeObject *py_type, PyStructSequence_InitType(py_type, py_sseq_desc); - /* initialize pytype */ + /* Initialize the Python type. */ py_struct_seq = PyStructSequence_New(py_type); BLI_assert(py_struct_seq != NULL); diff --git a/source/blender/python/intern/stubs.c b/source/blender/python/intern/stubs.c index c29f9188eea..f860bdc36ee 100644 --- a/source/blender/python/intern/stubs.c +++ b/source/blender/python/intern/stubs.c @@ -25,7 +25,7 @@ void BPY_pyconstraint_exec(struct bPythonConstraint *con, void BPY_pyconstraint_target(struct bPythonConstraint *con, struct bConstraintTarget *ct) { } -int BPY_is_pyconstraint(struct Text *text) +bool BPY_is_pyconstraint(struct Text *text) { return 0; } diff --git a/source/blender/python/mathutils/mathutils.c b/source/blender/python/mathutils/mathutils.c index 1aa2cec861c..7cba95a1f85 100644 --- a/source/blender/python/mathutils/mathutils.c +++ b/source/blender/python/mathutils/mathutils.c @@ -710,7 +710,7 @@ void BaseMathObject_dealloc(BaseMathObject *self) BaseMathObject_clear(self); } - Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); /* breaks subtypes. */ + Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); /* breaks sub-types. */ } /*----------------------------MODULE INIT-------------------------*/ @@ -724,7 +724,7 @@ static struct PyModuleDef M_Mathutils_module_def = { M_Mathutils_doc, /* m_doc */ 0, /* m_size */ M_Mathutils_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/mathutils/mathutils.h b/source/blender/python/mathutils/mathutils.h index 84386e99d18..27d84a80601 100644 --- a/source/blender/python/mathutils/mathutils.h +++ b/source/blender/python/mathutils/mathutils.h @@ -6,7 +6,7 @@ * \ingroup pymathutils */ -/* Can cast different mathutils types to this, use for generic funcs */ +/* Can cast different mathutils types to this, use for generic functions. */ #include "BLI_compiler_attrs.h" @@ -21,7 +21,7 @@ extern char BaseMathObject_owner_doc[]; ((struct_name *)((base_type ? (base_type)->tp_alloc(base_type, 0) : \ _PyObject_GC_New(&(root_type))))) -/** BaseMathObject.flag */ +/** #BaseMathObject.flag */ enum { /** * Do not own the memory used in this vector, @@ -43,9 +43,9 @@ enum { float *_data; \ /** If this vector references another object, otherwise NULL, *Note* this owns its reference */ \ PyObject *cb_user; \ - /** Which user funcs do we adhere to, RNA, etc */ \ + /** Which user functions do we adhere to, RNA, etc */ \ unsigned char cb_type; \ - /** Subtype: location, rotation... \ + /** Sub-type: location, rotation... \ * to avoid defining many new functions for every attribute of the same type */ \ unsigned char cb_subtype; \ /** Wrapped data type. */ \ diff --git a/source/blender/python/mathutils/mathutils_Color.c b/source/blender/python/mathutils/mathutils_Color.c index 88e8d880360..a66178baefc 100644 --- a/source/blender/python/mathutils/mathutils_Color.c +++ b/source/blender/python/mathutils/mathutils_Color.c @@ -14,7 +14,9 @@ #include "../generic/py_capi_utils.h" #include "../generic/python_utildefines.h" -#include "IMB_colormanagement.h" +#ifndef MATH_STANDALONE +# include "IMB_colormanagement.h" +#endif #ifndef MATH_STANDALONE # include "BLI_dynstr.h" @@ -92,6 +94,8 @@ static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds) /** \name Color Methods: Color Space Conversion * \{ */ +#ifndef MATH_STANDALONE + PyDoc_STRVAR(Color_from_scene_linear_to_srgb_doc, ".. function:: from_scene_linear_to_srgb()\n" "\n" @@ -204,6 +208,8 @@ static PyObject *Color_from_rec709_linear_to_scene_linear(ColorObject *self) return Color_CreatePyObject(col, Py_TYPE(self)); } +#endif /* MATH_STANDALONE */ + /** \} */ /* -------------------------------------------------------------------- */ @@ -1050,7 +1056,8 @@ static struct PyMethodDef Color_methods[] = { /* base-math methods */ {"freeze", (PyCFunction)BaseMathObject_freeze, METH_NOARGS, BaseMathObject_freeze_doc}, - /* Color-space methods. */ +/* Color-space methods. */ +#ifndef MATH_STANDALONE {"from_scene_linear_to_srgb", (PyCFunction)Color_from_scene_linear_to_srgb, METH_NOARGS, @@ -1083,6 +1090,8 @@ static struct PyMethodDef Color_methods[] = { (PyCFunction)Color_from_rec709_linear_to_scene_linear, METH_NOARGS, Color_from_rec709_linear_to_scene_linear_doc}, +#endif /* MATH_STANDALONE */ + {NULL, NULL, 0, NULL}, }; @@ -1102,7 +1111,7 @@ PyDoc_STRVAR( " the OpenColorIO configuration. The notable exception is user interface theming colors, " " which are in sRGB color space.\n" "\n" - " :param rgb: (r, g, b) color values\n" + " :arg rgb: (r, g, b) color values\n" " :type rgb: 3d vector\n"); PyTypeObject color_Type = { PyVarObject_HEAD_INIT(NULL, 0) "Color", /* tp_name */ diff --git a/source/blender/python/mathutils/mathutils_Euler.c b/source/blender/python/mathutils/mathutils_Euler.c index f49868dfba7..8f950bce344 100644 --- a/source/blender/python/mathutils/mathutils_Euler.c +++ b/source/blender/python/mathutils/mathutils_Euler.c @@ -774,9 +774,9 @@ PyDoc_STRVAR( "\n" " .. seealso:: `Euler angles <https://en.wikipedia.org/wiki/Euler_angles>`__ on Wikipedia.\n" "\n" - " :param angles: Three angles, in radians.\n" + " :arg angles: Three angles, in radians.\n" " :type angles: 3d vector\n" - " :param order: Optional order of the angles, a permutation of ``XYZ``.\n" + " :arg order: Optional order of the angles, a permutation of ``XYZ``.\n" " :type order: str\n"); PyTypeObject euler_Type = { PyVarObject_HEAD_INIT(NULL, 0) "Euler", /* tp_name */ diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c index 1e85ece124d..af01c571fe9 100644 --- a/source/blender/python/mathutils/mathutils_Matrix.c +++ b/source/blender/python/mathutils/mathutils_Matrix.c @@ -1244,12 +1244,11 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self) return NULL; } if (self->row_num == 3) { - mat3_to_quat(quat, (float(*)[3])self->matrix); + mat3_to_quat(quat, (const float(*)[3])self->matrix); } else { mat4_to_quat(quat, (const float(*)[4])self->matrix); } - return Quaternion_CreatePyObject(quat, NULL); } @@ -1888,7 +1887,7 @@ static PyObject *Matrix_decompose(MatrixObject *self) } mat4_to_loc_rot_size(loc, rot, size, (const float(*)[4])self->matrix); - mat3_to_quat(quat, rot); + mat3_normalized_to_quat_fast(quat, rot); ret = PyTuple_New(3); PyTuple_SET_ITEMS(ret, @@ -3322,8 +3321,7 @@ PyDoc_STRVAR( " This object gives access to Matrices in Blender, supporting square and rectangular\n" " matrices from 2x2 up to 4x4.\n" "\n" - " :param rows: Sequence of rows.\n" - " When omitted, a 4x4 identity matrix is constructed.\n" + " :arg rows: Sequence of rows. When omitted, a 4x4 identity matrix is constructed.\n" " :type rows: 2d number sequence\n"); PyTypeObject matrix_Type = { PyVarObject_HEAD_INIT(NULL, 0) "Matrix", /*tp_name*/ diff --git a/source/blender/python/mathutils/mathutils_Quaternion.c b/source/blender/python/mathutils/mathutils_Quaternion.c index 6994a313237..d405d5e63ce 100644 --- a/source/blender/python/mathutils/mathutils_Quaternion.c +++ b/source/blender/python/mathutils/mathutils_Quaternion.c @@ -543,7 +543,6 @@ static PyObject *Quaternion_rotate(QuaternionObject *self, PyObject *value) length = normalize_qt_qt(tquat, self->quat); quat_to_mat3(self_rmat, tquat); mul_m3_m3m3(rmat, other_rmat, self_rmat); - mat3_to_quat(self->quat, rmat); mul_qt_fl(self->quat, length); /* maintain length after rotating */ @@ -1663,9 +1662,9 @@ PyDoc_STRVAR(quaternion_doc, "\n" " This object gives access to Quaternions in Blender.\n" "\n" - " :param seq: size 3 or 4\n" + " :arg seq: size 3 or 4\n" " :type seq: :class:`Vector`\n" - " :param angle: rotation angle, in radians\n" + " :arg angle: rotation angle, in radians\n" " :type angle: float\n" "\n" " The constructor takes arguments in various forms:\n" diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c index 0c9cbd6ccfa..161f05deafd 100644 --- a/source/blender/python/mathutils/mathutils_Vector.c +++ b/source/blender/python/mathutils/mathutils_Vector.c @@ -3188,7 +3188,7 @@ PyDoc_STRVAR(vector_doc, "\n" " This object gives access to Vectors in Blender.\n" "\n" - " :param seq: Components of the vector, must be a sequence of at least two\n" + " :arg seq: Components of the vector, must be a sequence of at least two\n" " :type seq: sequence of numbers\n"); PyTypeObject vector_Type = { PyVarObject_HEAD_INIT(NULL, 0) @@ -3304,7 +3304,7 @@ PyObject *Vector_CreatePyObject(const float *vec, const int vec_num, PyTypeObjec self->vec = vec_alloc; self->vec_num = vec_num; - /* init callbacks as NULL */ + /* Initialize callbacks as NULL. */ self->cb_user = NULL; self->cb_type = self->cb_subtype = 0; @@ -3339,7 +3339,7 @@ PyObject *Vector_CreatePyObject_wrap(float *vec, const int vec_num, PyTypeObject if (self) { self->vec_num = vec_num; - /* init callbacks as NULL */ + /* Initialize callbacks as NULL. */ self->cb_user = NULL; self->cb_type = self->cb_subtype = 0; diff --git a/source/blender/python/mathutils/mathutils_bvhtree.c b/source/blender/python/mathutils/mathutils_bvhtree.c index ead255a6716..4bdb1adcdde 100644 --- a/source/blender/python/mathutils/mathutils_bvhtree.c +++ b/source/blender/python/mathutils/mathutils_bvhtree.c @@ -1148,12 +1148,12 @@ static PyObject *C_BVHTree_FromObject(PyObject *UNUSED(cls), PyObject *args, PyO coords = MEM_mallocN(sizeof(*coords) * (size_t)coords_len, __func__); tris = MEM_mallocN(sizeof(*tris) * (size_t)tris_len, __func__); - MVert *mv = mesh->mvert; - for (int i = 0; i < mesh->totvert; i++, mv++) { - copy_v3_v3(coords[i], mv->co); + const MVert *verts = BKE_mesh_verts(mesh); + for (int i = 0; i < mesh->totvert; i++) { + copy_v3_v3(coords[i], verts[i].co); } - mloop = mesh->mloop; + mloop = BKE_mesh_loops(mesh); } { @@ -1294,7 +1294,7 @@ static struct PyModuleDef bvhtree_moduledef = { py_bvhtree_doc, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/mathutils/mathutils_geometry.c b/source/blender/python/mathutils/mathutils_geometry.c index 1e492574903..28deebcf5ac 100644 --- a/source/blender/python/mathutils/mathutils_geometry.c +++ b/source/blender/python/mathutils/mathutils_geometry.c @@ -1790,7 +1790,7 @@ static struct PyModuleDef M_Geometry_module_def = { M_Geometry_doc, /* m_doc */ 0, /* m_size */ M_Geometry_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/mathutils/mathutils_interpolate.c b/source/blender/python/mathutils/mathutils_interpolate.c index 6523b3f7259..10f42d9b070 100644 --- a/source/blender/python/mathutils/mathutils_interpolate.c +++ b/source/blender/python/mathutils/mathutils_interpolate.c @@ -93,7 +93,7 @@ static struct PyModuleDef M_Interpolate_module_def = { M_Interpolate_doc, /* m_doc */ 0, /* m_size */ M_Interpolate_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/mathutils/mathutils_kdtree.c b/source/blender/python/mathutils/mathutils_kdtree.c index 66c48697b6b..f5a27c6f90f 100644 --- a/source/blender/python/mathutils/mathutils_kdtree.c +++ b/source/blender/python/mathutils/mathutils_kdtree.c @@ -428,7 +428,7 @@ static struct PyModuleDef kdtree_moduledef = { py_kdtree_doc, /* m_doc */ 0, /* m_size */ NULL, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ diff --git a/source/blender/python/mathutils/mathutils_noise.c b/source/blender/python/mathutils/mathutils_noise.c index e1282e90c48..3a3297f27f7 100644 --- a/source/blender/python/mathutils/mathutils_noise.c +++ b/source/blender/python/mathutils/mathutils_noise.c @@ -1089,7 +1089,7 @@ static struct PyModuleDef M_Noise_module_def = { M_Noise_doc, /* m_doc */ 0, /* m_size */ M_Noise_methods, /* m_methods */ - NULL, /* m_reload */ + NULL, /* m_slots */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL, /* m_free */ |