archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

picky formatting of mathutils

Browse Source
This commit is contained in:
Campbell Barton
2011-12-24 13:26:30 +00:00
parent 84c8fde2ae
commit f3ac865cc0
9 changed files with 561 additions and 562 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
source/blender/python/mathutils/mathutils.c
View File

@@ -49,10 +49,10 @@ static int mathutils_array_parse_fast(float *array,
int i; int i;
i= size; i = size;
do { do {
i--; i--;
if ( ((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) && if ( ((array[i] = PyFloat_AsDouble((item = PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) &&
PyErr_Occurred()) PyErr_Occurred())
{ {
PyErr_Format(PyExc_TypeError, PyErr_Format(PyExc_TypeError,
@@ -75,10 +75,10 @@ int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *
#if 1 /* approx 6x speedup for mathutils types */ #if 1 /* approx 6x speedup for mathutils types */
if ( (size= VectorObject_Check(value) ? ((VectorObject *)value)->size : 0) || if ( (size = VectorObject_Check(value) ? ((VectorObject *)value)->size : 0) ||
(size= EulerObject_Check(value) ? 3 : 0) || (size = EulerObject_Check(value) ? 3 : 0) ||
(size= QuaternionObject_Check(value) ? 4 : 0) || (size = QuaternionObject_Check(value) ? 4 : 0) ||
(size= ColorObject_Check(value) ? 3 : 0)) (size = ColorObject_Check(value) ? 3 : 0))
{ {
if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) { if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
return -1; return -1;
@@ -104,15 +104,15 @@ int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *
else else
#endif #endif
{ {
PyObject *value_fast= NULL; PyObject *value_fast = NULL;
/* non list/tuple cases */ /* non list/tuple cases */
if (!(value_fast=PySequence_Fast(value, error_prefix))) { if (!(value_fast = PySequence_Fast(value, error_prefix))) {
/* PySequence_Fast sets the error */ /* PySequence_Fast sets the error */
return -1; return -1;
} }
size= PySequence_Fast_GET_SIZE(value_fast); size = PySequence_Fast_GET_SIZE(value_fast);
if (size > array_max || size < array_min) { if (size > array_max || size < array_min) {
if (array_max == array_min) { if (array_max == array_min) {
@@ -139,10 +139,10 @@ int mathutils_array_parse_alloc(float **array, int array_min, PyObject *value, c
#if 1 /* approx 6x speedup for mathutils types */ #if 1 /* approx 6x speedup for mathutils types */
if ( (size= VectorObject_Check(value) ? ((VectorObject *)value)->size : 0) || if ( (size = VectorObject_Check(value) ? ((VectorObject *)value)->size : 0) ||
(size= EulerObject_Check(value) ? 3 : 0) || (size = EulerObject_Check(value) ? 3 : 0) ||
(size= QuaternionObject_Check(value) ? 4 : 0) || (size = QuaternionObject_Check(value) ? 4 : 0) ||
(size= ColorObject_Check(value) ? 3 : 0)) (size = ColorObject_Check(value) ? 3 : 0))
{ {
if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) { if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
return -1; return -1;
@@ -155,23 +155,23 @@ int mathutils_array_parse_alloc(float **array, int array_min, PyObject *value, c
return -1; return -1;
} }
*array= PyMem_Malloc(size * sizeof(float)); *array = PyMem_Malloc(size * sizeof(float));
memcpy(*array, ((BaseMathObject *)value)->data, size * sizeof(float)); memcpy(*array, ((BaseMathObject *)value)->data, size * sizeof(float));
return size; return size;
} }
else else
#endif #endif
{ {
PyObject *value_fast= NULL; PyObject *value_fast = NULL;
//*array= NULL; //*array = NULL;
/* non list/tuple cases */ /* non list/tuple cases */
if (!(value_fast=PySequence_Fast(value, error_prefix))) { if (!(value_fast = PySequence_Fast(value, error_prefix))) {
/* PySequence_Fast sets the error */ /* PySequence_Fast sets the error */
return -1; return -1;
} }
size= PySequence_Fast_GET_SIZE(value_fast); size = PySequence_Fast_GET_SIZE(value_fast);
if (size < array_min) { if (size < array_min) {
PyErr_Format(PyExc_ValueError, PyErr_Format(PyExc_ValueError,
@@ -180,7 +180,7 @@ int mathutils_array_parse_alloc(float **array, int array_min, PyObject *value, c
return -1; return -1;
} }
*array= PyMem_Malloc(size * sizeof(float)); *array = PyMem_Malloc(size * sizeof(float));
return mathutils_array_parse_fast(*array, size, value_fast, error_prefix); return mathutils_array_parse_fast(*array, size, value_fast, error_prefix);
} }
@@ -261,7 +261,7 @@ int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps) int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
{ {
int x; int x;
for (x=0; x< size; x++) { for (x = 0; x < size; x++) {
if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0) if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
return 0; return 0;
} }
@@ -291,8 +291,8 @@ int Mathutils_RegisterCallback(Mathutils_Callback *cb)
int i; int i;
/* find the first free slot */ /* find the first free slot */
for (i= 0; mathutils_callbacks[i]; i++) { for (i = 0; mathutils_callbacks[i]; i++) {
if (mathutils_callbacks[i]==cb) /* already registered? */ if (mathutils_callbacks[i] == cb) /* already registered? */
return i; return i;
} }
@@ -303,7 +303,7 @@ int Mathutils_RegisterCallback(Mathutils_Callback *cb)
/* use macros to check for NULL */ /* use macros to check for NULL */
int _BaseMathObject_ReadCallback(BaseMathObject *self) int _BaseMathObject_ReadCallback(BaseMathObject *self)
{ {
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type]; Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
if (cb->get(self, self->cb_subtype) != -1) if (cb->get(self, self->cb_subtype) != -1)
return 0; return 0;
@@ -317,7 +317,7 @@ int _BaseMathObject_ReadCallback(BaseMathObject *self)
int _BaseMathObject_WriteCallback(BaseMathObject *self) int _BaseMathObject_WriteCallback(BaseMathObject *self)
{ {
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type]; Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
if (cb->set(self, self->cb_subtype) != -1) if (cb->set(self, self->cb_subtype) != -1)
return 0; return 0;
@@ -331,7 +331,7 @@ int _BaseMathObject_WriteCallback(BaseMathObject *self)
int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index) int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
{ {
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type]; Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
if (cb->get_index(self, self->cb_subtype, index) != -1) if (cb->get_index(self, self->cb_subtype, index) != -1)
return 0; return 0;
@@ -345,7 +345,7 @@ int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index) int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
{ {
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type]; Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
if (cb->set_index(self, self->cb_subtype, index) != -1) if (cb->set_index(self, self->cb_subtype, index) != -1)
return 0; return 0;
@@ -361,7 +361,7 @@ int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
char BaseMathObject_owner_doc[] = "The item this is wrapping or None (readonly)."; char BaseMathObject_owner_doc[] = "The item this is wrapping or None (readonly).";
PyObject *BaseMathObject_owner_get(BaseMathObject *self, void *UNUSED(closure)) PyObject *BaseMathObject_owner_get(BaseMathObject *self, void *UNUSED(closure))
{ {
PyObject *ret= self->cb_user ? self->cb_user : Py_None; PyObject *ret = self->cb_user ? self->cb_user : Py_None;
Py_INCREF(ret); Py_INCREF(ret);
return ret; return ret;
} }
@@ -420,7 +420,7 @@ PyMODINIT_FUNC PyInit_mathutils(void)
{ {
PyObject *submodule; PyObject *submodule;
PyObject *item; PyObject *item;
PyObject *sys_modules= PyThreadState_GET()->interp->modules; PyObject *sys_modules = PyThreadState_GET()->interp->modules;
if (PyType_Ready(&vector_Type) < 0) if (PyType_Ready(&vector_Type) < 0)
return NULL; return NULL;
@@ -445,7 +445,7 @@ PyMODINIT_FUNC PyInit_mathutils(void)
PyModule_AddObject(submodule, "Color", (PyObject *)&color_Type); PyModule_AddObject(submodule, "Color", (PyObject *)&color_Type);
/* submodule */ /* submodule */
PyModule_AddObject(submodule, "geometry", (item=PyInit_mathutils_geometry())); PyModule_AddObject(submodule, "geometry", (item = PyInit_mathutils_geometry()));
/* XXX, python doesnt do imports with this usefully yet /* XXX, python doesnt do imports with this usefully yet
* 'from mathutils.geometry import PolyFill' * 'from mathutils.geometry import PolyFill'
* ...fails without this. */ * ...fails without this. */
@@ -453,12 +453,12 @@ PyMODINIT_FUNC PyInit_mathutils(void)
Py_INCREF(item); Py_INCREF(item);
/* Noise submodule */ /* Noise submodule */
PyModule_AddObject(submodule, "noise", (item=PyInit_mathutils_noise())); PyModule_AddObject(submodule, "noise", (item = PyInit_mathutils_noise()));
PyDict_SetItemString(sys_modules, "mathutils.noise", item); PyDict_SetItemString(sys_modules, "mathutils.noise", item);
Py_INCREF(item); Py_INCREF(item);
mathutils_matrix_row_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_row_cb); mathutils_matrix_row_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_row_cb);
mathutils_matrix_col_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_col_cb); mathutils_matrix_col_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_col_cb);
return submodule; return submodule;
} }

102
source/blender/python/mathutils/mathutils_Color.c
View File

@@ -40,7 +40,7 @@
//makes a new color for you to play with //makes a new color for you to play with
static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject *Color_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{ {
float col[3]= {0.0f, 0.0f, 0.0f}; float col[3] = {0.0f, 0.0f, 0.0f};
if (kwds && PyDict_Size(kwds)) { if (kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
@@ -73,15 +73,15 @@ static PyObject *Color_ToTupleExt(ColorObject *self, int ndigits)
PyObject *ret; PyObject *ret;
int i; int i;
ret= PyTuple_New(COLOR_SIZE); ret = PyTuple_New(COLOR_SIZE);
if (ndigits >= 0) { if (ndigits >= 0) {
for (i= 0; i < COLOR_SIZE; i++) { for (i = 0; i < COLOR_SIZE; i++) {
PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->col[i], ndigits))); PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->col[i], ndigits)));
} }
} }
else { else {
for (i= 0; i < COLOR_SIZE; i++) { for (i = 0; i < COLOR_SIZE; i++) {
PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->col[i])); PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->col[i]));
} }
} }
@@ -118,9 +118,9 @@ static PyObject *Color_repr(ColorObject * self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
tuple= Color_ToTupleExt(self, -1); tuple = Color_ToTupleExt(self, -1);
ret= PyUnicode_FromFormat("Color(%R)", tuple); ret = PyUnicode_FromFormat("Color(%R)", tuple);
Py_DECREF(tuple); Py_DECREF(tuple);
return ret; return ret;
@@ -133,7 +133,7 @@ static PyObject *Color_str(ColorObject * self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
ds= BLI_dynstr_new(); ds = BLI_dynstr_new();
BLI_dynstr_appendf(ds, "<Color (r=%.4f, g=%.4f, b=%.4f)>", BLI_dynstr_appendf(ds, "<Color (r=%.4f, g=%.4f, b=%.4f)>",
self->col[0], self->col[1], self->col[2]); self->col[0], self->col[1], self->col[2]);
@@ -143,19 +143,19 @@ static PyObject *Color_str(ColorObject * self)
//------------------------tp_richcmpr //------------------------tp_richcmpr
//returns -1 execption, 0 false, 1 true //returns -1 execption, 0 false, 1 true
static PyObject* Color_richcmpr(PyObject *a, PyObject *b, int op) static PyObject *Color_richcmpr(PyObject *a, PyObject *b, int op)
{ {
PyObject *res; PyObject *res;
int ok= -1; /* zero is true */ int ok = -1; /* zero is true */
if (ColorObject_Check(a) && ColorObject_Check(b)) { if (ColorObject_Check(a) && ColorObject_Check(b)) {
ColorObject *colA= (ColorObject*)a; ColorObject *colA = (ColorObject *)a;
ColorObject *colB= (ColorObject*)b; ColorObject *colB = (ColorObject *)b;
if (BaseMath_ReadCallback(colA) == -1 || BaseMath_ReadCallback(colB) == -1) if (BaseMath_ReadCallback(colA) == -1 || BaseMath_ReadCallback(colB) == -1)
return NULL; return NULL;
ok= EXPP_VectorsAreEqual(colA->col, colB->col, COLOR_SIZE, 1) ? 0 : -1; ok = EXPP_VectorsAreEqual(colA->col, colB->col, COLOR_SIZE, 1) ? 0 : -1;
} }
switch (op) { switch (op) {
@@ -190,7 +190,7 @@ static int Color_len(ColorObject *UNUSED(self))
//sequence accessor (get) //sequence accessor (get)
static PyObject *Color_item(ColorObject * self, int i) static PyObject *Color_item(ColorObject * self, int i)
{ {
if (i<0) i= COLOR_SIZE-i; if (i < 0) i = COLOR_SIZE - i;
if (i < 0 || i >= COLOR_SIZE) { if (i < 0 || i >= COLOR_SIZE) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
@@ -218,7 +218,7 @@ static int Color_ass_item(ColorObject * self, int i, PyObject *value)
return -1; return -1;
} }
if (i<0) i= COLOR_SIZE-i; if (i < 0) i= COLOR_SIZE - i;
if (i < 0 || i >= COLOR_SIZE) { if (i < 0 || i >= COLOR_SIZE) {
PyErr_SetString(PyExc_IndexError, "color[attribute] = x: " PyErr_SetString(PyExc_IndexError, "color[attribute] = x: "
@@ -244,12 +244,12 @@ static PyObject *Color_slice(ColorObject * self, int begin, int end)
return NULL; return NULL;
CLAMP(begin, 0, COLOR_SIZE); CLAMP(begin, 0, COLOR_SIZE);
if (end<0) end= (COLOR_SIZE + 1) + end; if (end < 0) end = (COLOR_SIZE + 1) + end;
CLAMP(end, 0, COLOR_SIZE); CLAMP(end, 0, COLOR_SIZE);
begin= MIN2(begin, end); begin = MIN2(begin, end);
tuple= PyTuple_New(end - begin); tuple = PyTuple_New(end - begin);
for (count= begin; count < end; count++) { for (count = begin; count < end; count++) {
PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->col[count])); PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->col[count]));
} }
@@ -266,11 +266,11 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq)
return -1; return -1;
CLAMP(begin, 0, COLOR_SIZE); CLAMP(begin, 0, COLOR_SIZE);
if (end<0) end= (COLOR_SIZE + 1) + end; if (end < 0) end = (COLOR_SIZE + 1) + end;
CLAMP(end, 0, COLOR_SIZE); CLAMP(end, 0, COLOR_SIZE);
begin = MIN2(begin, end); begin = MIN2(begin, end);
if ((size=mathutils_array_parse(col, 0, COLOR_SIZE, seq, "mathutils.Color[begin:end] = []")) == -1) if ((size = mathutils_array_parse(col, 0, COLOR_SIZE, seq, "mathutils.Color[begin:end] = []")) == -1)
return -1; return -1;
if (size != (end - begin)) { if (size != (end - begin)) {
@@ -280,7 +280,7 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq)
return -1; return -1;
} }
for (i= 0; i < COLOR_SIZE; i++) for (i = 0; i < COLOR_SIZE; i++)
self->col[begin + i] = col[i]; self->col[begin + i] = col[i];
(void)BaseMath_WriteCallback(self); (void)BaseMath_WriteCallback(self);
@@ -392,8 +392,8 @@ static PyObject *Color_add(PyObject *v1, PyObject *v2)
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL; return NULL;
} }
color1 = (ColorObject*)v1; color1 = (ColorObject *)v1;
color2 = (ColorObject*)v2; color2 = (ColorObject *)v2;
if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1)
return NULL; return NULL;
@@ -415,8 +415,8 @@ static PyObject *Color_iadd(PyObject *v1, PyObject *v2)
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL; return NULL;
} }
color1 = (ColorObject*)v1; color1 = (ColorObject *)v1;
color2 = (ColorObject*)v2; color2 = (ColorObject *)v2;
if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1)
return NULL; return NULL;
@@ -441,8 +441,8 @@ static PyObject *Color_sub(PyObject *v1, PyObject *v2)
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL; return NULL;
} }
color1 = (ColorObject*)v1; color1 = (ColorObject *)v1;
color2 = (ColorObject*)v2; color2 = (ColorObject *)v2;
if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1)
return NULL; return NULL;
@@ -455,7 +455,7 @@ static PyObject *Color_sub(PyObject *v1, PyObject *v2)
/* subtraction in-place: obj -= obj */ /* subtraction in-place: obj -= obj */
static PyObject *Color_isub(PyObject *v1, PyObject *v2) static PyObject *Color_isub(PyObject *v1, PyObject *v2)
{ {
ColorObject *color1= NULL, *color2= NULL; ColorObject *color1 = NULL, *color2 = NULL;
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) { if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
PyErr_Format(PyExc_TypeError, PyErr_Format(PyExc_TypeError,
@@ -464,8 +464,8 @@ static PyObject *Color_isub(PyObject *v1, PyObject *v2)
Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name); Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL; return NULL;
} }
color1 = (ColorObject*)v1; color1 = (ColorObject *)v1;
color2 = (ColorObject*)v2; color2 = (ColorObject *)v2;
if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1) if (BaseMath_ReadCallback(color1) == -1 || BaseMath_ReadCallback(color2) == -1)
return NULL; return NULL;
@@ -491,12 +491,12 @@ static PyObject *Color_mul(PyObject *v1, PyObject *v2)
float scalar; float scalar;
if ColorObject_Check(v1) { if ColorObject_Check(v1) {
color1= (ColorObject *)v1; color1 = (ColorObject *)v1;
if (BaseMath_ReadCallback(color1) == -1) if (BaseMath_ReadCallback(color1) == -1)
return NULL; return NULL;
} }
if ColorObject_Check(v2) { if ColorObject_Check(v2) {
color2= (ColorObject *)v2; color2 = (ColorObject *)v2;
if (BaseMath_ReadCallback(color2) == -1) if (BaseMath_ReadCallback(color2) == -1)
return NULL; return NULL;
} }
@@ -507,12 +507,12 @@ static PyObject *Color_mul(PyObject *v1, PyObject *v2)
/* col * col, dont support yet! */ /* col * col, dont support yet! */
} }
else if (color1) { else if (color1) {
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR * FLOAT */ if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* COLOR * FLOAT */
return color_mul_float(color1, scalar); return color_mul_float(color1, scalar);
} }
} }
else if (color2) { else if (color2) {
if (((scalar= PyFloat_AsDouble(v1)) == -1.0f && PyErr_Occurred())==0) { /* FLOAT * COLOR */ if (((scalar = PyFloat_AsDouble(v1)) == -1.0f && PyErr_Occurred()) == 0) { /* FLOAT * COLOR */
return color_mul_float(color2, scalar); return color_mul_float(color2, scalar);
} }
} }
@@ -533,7 +533,7 @@ static PyObject *Color_div(PyObject *v1, PyObject *v2)
float scalar; float scalar;
if ColorObject_Check(v1) { if ColorObject_Check(v1) {
color1= (ColorObject *)v1; color1 = (ColorObject *)v1;
if (BaseMath_ReadCallback(color1) == -1) if (BaseMath_ReadCallback(color1) == -1)
return NULL; return NULL;
} }
@@ -544,8 +544,8 @@ static PyObject *Color_div(PyObject *v1, PyObject *v2)
} }
/* make sure v1 is always the vector */ /* make sure v1 is always the vector */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR * FLOAT */ if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* COLOR * FLOAT */
if (scalar==0.0f) { if (scalar == 0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, PyErr_SetString(PyExc_ZeroDivisionError,
"Color division: divide by zero error"); "Color division: divide by zero error");
return NULL; return NULL;
@@ -570,7 +570,7 @@ static PyObject *Color_imul(PyObject *v1, PyObject *v2)
return NULL; return NULL;
/* only support color *= float */ /* only support color *= float */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR *= FLOAT */ if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* COLOR *= FLOAT */
mul_vn_fl(color->col, COLOR_SIZE, scalar); mul_vn_fl(color->col, COLOR_SIZE, scalar);
} }
else { else {
@@ -596,8 +596,8 @@ static PyObject *Color_idiv(PyObject *v1, PyObject *v2)
return NULL; return NULL;
/* only support color /= float */ /* only support color /= float */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR /= FLOAT */ if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* COLOR /= FLOAT */
if (scalar==0.0f) { if (scalar == 0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, PyErr_SetString(PyExc_ZeroDivisionError,
"Color division: divide by zero error"); "Color division: divide by zero error");
return NULL; return NULL;
@@ -619,7 +619,7 @@ static PyObject *Color_idiv(PyObject *v1, PyObject *v2)
} }
/* -obj /* -obj
returns the negative of this object*/ returns the negative of this object */
static PyObject *Color_neg(ColorObject *self) static PyObject *Color_neg(ColorObject *self)
{ {
float tcol[COLOR_SIZE]; float tcol[COLOR_SIZE];
@@ -684,7 +684,7 @@ static int Color_channel_set(ColorObject * self, PyObject *value, void * type)
static PyObject *Color_channel_hsv_get(ColorObject * self, void *type) static PyObject *Color_channel_hsv_get(ColorObject * self, void *type)
{ {
float hsv[3]; float hsv[3];
int i= GET_INT_FROM_POINTER(type); int i = GET_INT_FROM_POINTER(type);
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
@@ -697,7 +697,7 @@ static PyObject *Color_channel_hsv_get(ColorObject * self, void *type)
static int Color_channel_hsv_set(ColorObject * self, PyObject *value, void * type) static int Color_channel_hsv_set(ColorObject * self, PyObject *value, void * type)
{ {
float hsv[3]; float hsv[3];
int i= GET_INT_FROM_POINTER(type); int i = GET_INT_FROM_POINTER(type);
float f = PyFloat_AsDouble(value); float f = PyFloat_AsDouble(value);
if (f == -1 && PyErr_Occurred()) { if (f == -1 && PyErr_Occurred()) {
@@ -732,7 +732,7 @@ static PyObject *Color_hsv_get(ColorObject * self, void *UNUSED(closure))
rgb_to_hsv(self->col[0], self->col[1], self->col[2], &(hsv[0]), &(hsv[1]), &(hsv[2])); rgb_to_hsv(self->col[0], self->col[1], self->col[2], &(hsv[0]), &(hsv[1]), &(hsv[2]));
ret= PyTuple_New(3); ret = PyTuple_New(3);
PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(hsv[0])); PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(hsv[0]));
PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(hsv[1])); PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(hsv[1]));
PyTuple_SET_ITEM(ret, 2, PyFloat_FromDouble(hsv[2])); PyTuple_SET_ITEM(ret, 2, PyFloat_FromDouble(hsv[2]));
@@ -847,13 +847,13 @@ PyObject *Color_CreatePyObject(float *col, int type, PyTypeObject *base_type)
{ {
ColorObject *self; ColorObject *self;
self= base_type ? (ColorObject *)base_type->tp_alloc(base_type, 0) : self = base_type ? (ColorObject *)base_type->tp_alloc(base_type, 0) :
(ColorObject *)PyObject_GC_New(ColorObject, &color_Type); (ColorObject *)PyObject_GC_New(ColorObject, &color_Type);
if (self) { if (self) {
/* init callbacks as NULL */ /* init callbacks as NULL */
self->cb_user= NULL; self->cb_user = NULL;
self->cb_type= self->cb_subtype= 0; self->cb_type = self->cb_subtype = 0;
if (type == Py_WRAP) { if (type == Py_WRAP) {
self->col = col; self->col = col;
@@ -878,12 +878,12 @@ PyObject *Color_CreatePyObject(float *col, int type, PyTypeObject *base_type)
PyObject *Color_CreatePyObject_cb(PyObject *cb_user, int cb_type, int cb_subtype) PyObject *Color_CreatePyObject_cb(PyObject *cb_user, int cb_type, int cb_subtype)
{ {
ColorObject *self= (ColorObject *)Color_CreatePyObject(NULL, Py_NEW, NULL); ColorObject *self = (ColorObject *)Color_CreatePyObject(NULL, Py_NEW, NULL);
if (self) { if (self) {
Py_INCREF(cb_user); Py_INCREF(cb_user);
self->cb_user= cb_user; self->cb_user = cb_user;
self->cb_type= (unsigned char)cb_type; self->cb_type = (unsigned char)cb_type;
self->cb_subtype= (unsigned char)cb_subtype; self->cb_subtype = (unsigned char)cb_subtype;
PyObject_GC_Track(self); PyObject_GC_Track(self);
} }

74
source/blender/python/mathutils/mathutils_Euler.c
View File

@@ -44,11 +44,11 @@
//makes a new euler for you to play with //makes a new euler for you to play with
static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{ {
PyObject *seq= NULL; PyObject *seq = NULL;
const char *order_str= NULL; const char *order_str = NULL;
float eul[EULER_SIZE]= {0.0f, 0.0f, 0.0f}; float eul[EULER_SIZE] = {0.0f, 0.0f, 0.0f};
short order= EULER_ORDER_XYZ; short order = EULER_ORDER_XYZ;
if (kwds && PyDict_Size(kwds)) { if (kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
@@ -64,7 +64,7 @@ static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
case 0: case 0:
break; break;
case 2: case 2:
if ((order=euler_order_from_string(order_str, "mathutils.Euler()")) == -1) if ((order = euler_order_from_string(order_str, "mathutils.Euler()")) == -1)
return NULL; return NULL;
/* intentionally pass through */ /* intentionally pass through */
case 1: case 1:
@@ -79,12 +79,12 @@ static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
static const char *euler_order_str(EulerObject *self) static const char *euler_order_str(EulerObject *self)
{ {
static const char order[][4] = {"XYZ", "XZY", "YXZ", "YZX", "ZXY", "ZYX"}; static const char order[][4] = {"XYZ", "XZY", "YXZ", "YZX", "ZXY", "ZYX"};
return order[self->order-EULER_ORDER_XYZ]; return order[self->order - EULER_ORDER_XYZ];
} }
short euler_order_from_string(const char *str, const char *error_prefix) short euler_order_from_string(const char *str, const char *error_prefix)
{ {
if ((str[0] && str[1] && str[2] && str[3]=='\0')) { if ((str[0] && str[1] && str[2] && str[3] == '\0')) {
switch (*((PY_INT32_T *)str)) { switch (*((PY_INT32_T *)str)) {
case 'X'|'Y'<<8|'Z'<<16: return EULER_ORDER_XYZ; case 'X'|'Y'<<8|'Z'<<16: return EULER_ORDER_XYZ;
case 'X'|'Z'<<8|'Y'<<16: return EULER_ORDER_XZY; case 'X'|'Z'<<8|'Y'<<16: return EULER_ORDER_XZY;
@@ -107,15 +107,15 @@ static PyObject *Euler_ToTupleExt(EulerObject *self, int ndigits)
PyObject *ret; PyObject *ret;
int i; int i;
ret= PyTuple_New(EULER_SIZE); ret = PyTuple_New(EULER_SIZE);
if (ndigits >= 0) { if (ndigits >= 0) {
for (i= 0; i < EULER_SIZE; i++) { for (i = 0; i < EULER_SIZE; i++) {
PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->eul[i], ndigits))); PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->eul[i], ndigits)));
} }
} }
else { else {
for (i= 0; i < EULER_SIZE; i++) { for (i = 0; i < EULER_SIZE; i++) {
PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->eul[i])); PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->eul[i]));
} }
} }
@@ -310,9 +310,9 @@ static PyObject *Euler_repr(EulerObject * self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
tuple= Euler_ToTupleExt(self, -1); tuple = Euler_ToTupleExt(self, -1);
ret= PyUnicode_FromFormat("Euler(%R, '%s')", tuple, euler_order_str(self)); ret = PyUnicode_FromFormat("Euler(%R, '%s')", tuple, euler_order_str(self));
Py_DECREF(tuple); Py_DECREF(tuple);
return ret; return ret;
@@ -325,7 +325,7 @@ static PyObject *Euler_str(EulerObject * self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
ds= BLI_dynstr_new(); ds = BLI_dynstr_new();
BLI_dynstr_appendf(ds, "<Euler (x=%.4f, y=%.4f, z=%.4f), order='%s'>", BLI_dynstr_appendf(ds, "<Euler (x=%.4f, y=%.4f, z=%.4f), order='%s'>",
self->eul[0], self->eul[1], self->eul[2], euler_order_str(self)); self->eul[0], self->eul[1], self->eul[2], euler_order_str(self));
@@ -333,19 +333,19 @@ static PyObject *Euler_str(EulerObject * self)
return mathutils_dynstr_to_py(ds); /* frees ds */ return mathutils_dynstr_to_py(ds); /* frees ds */
} }
static PyObject* Euler_richcmpr(PyObject *a, PyObject *b, int op) static PyObject *Euler_richcmpr(PyObject *a, PyObject *b, int op)
{ {
PyObject *res; PyObject *res;
int ok= -1; /* zero is true */ int ok = -1; /* zero is true */
if (EulerObject_Check(a) && EulerObject_Check(b)) { if (EulerObject_Check(a) && EulerObject_Check(b)) {
EulerObject *eulA= (EulerObject*)a; EulerObject *eulA = (EulerObject *)a;
EulerObject *eulB= (EulerObject*)b; EulerObject *eulB = (EulerObject *)b;
if (BaseMath_ReadCallback(eulA) == -1 || BaseMath_ReadCallback(eulB) == -1) if (BaseMath_ReadCallback(eulA) == -1 || BaseMath_ReadCallback(eulB) == -1)
return NULL; return NULL;
ok= ((eulA->order == eulB->order) && EXPP_VectorsAreEqual(eulA->eul, eulB->eul, EULER_SIZE, 1)) ? 0 : -1; ok = ((eulA->order == eulB->order) && EXPP_VectorsAreEqual(eulA->eul, eulB->eul, EULER_SIZE, 1)) ? 0 : -1;
} }
switch (op) { switch (op) {
@@ -380,7 +380,7 @@ static int Euler_len(EulerObject *UNUSED(self))
//sequence accessor (get) //sequence accessor (get)
static PyObject *Euler_item(EulerObject * self, int i) static PyObject *Euler_item(EulerObject * self, int i)
{ {
if (i<0) i= EULER_SIZE-i; if (i < 0) i = EULER_SIZE - i;
if (i < 0 || i >= EULER_SIZE) { if (i < 0 || i >= EULER_SIZE) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
@@ -408,7 +408,7 @@ static int Euler_ass_item(EulerObject * self, int i, PyObject *value)
return -1; return -1;
} }
if (i<0) i= EULER_SIZE-i; if (i < 0) i = EULER_SIZE - i;
if (i < 0 || i >= EULER_SIZE) { if (i < 0 || i >= EULER_SIZE) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
@@ -435,11 +435,11 @@ static PyObject *Euler_slice(EulerObject * self, int begin, int end)
return NULL; return NULL;
CLAMP(begin, 0, EULER_SIZE); CLAMP(begin, 0, EULER_SIZE);
if (end<0) end= (EULER_SIZE + 1) + end; if (end < 0) end = (EULER_SIZE + 1) + end;
CLAMP(end, 0, EULER_SIZE); CLAMP(end, 0, EULER_SIZE);
begin= MIN2(begin, end); begin = MIN2(begin, end);
tuple= PyTuple_New(end - begin); tuple = PyTuple_New(end - begin);
for (count = begin; count < end; count++) { for (count = begin; count < end; count++) {
PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->eul[count])); PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->eul[count]));
} }
@@ -457,11 +457,11 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq)
return -1; return -1;
CLAMP(begin, 0, EULER_SIZE); CLAMP(begin, 0, EULER_SIZE);
if (end<0) end= (EULER_SIZE + 1) + end; if (end < 0) end = (EULER_SIZE + 1) + end;
CLAMP(end, 0, EULER_SIZE); CLAMP(end, 0, EULER_SIZE);
begin = MIN2(begin, end); begin = MIN2(begin, end);
if ((size=mathutils_array_parse(eul, 0, EULER_SIZE, seq, "mathutils.Euler[begin:end] = []")) == -1) if ((size = mathutils_array_parse(eul, 0, EULER_SIZE, seq, "mathutils.Euler[begin:end] = []")) == -1)
return -1; return -1;
if (size != (end - begin)) { if (size != (end - begin)) {
@@ -471,7 +471,7 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq)
return -1; return -1;
} }
for (i= 0; i < EULER_SIZE; i++) for (i = 0; i < EULER_SIZE; i++)
self->eul[begin + i] = eul[i]; self->eul[begin + i] = eul[i];
(void)BaseMath_WriteCallback(self); (void)BaseMath_WriteCallback(self);
@@ -592,13 +592,13 @@ static PyObject *Euler_order_get(EulerObject *self, void *UNUSED(closure))
static int Euler_order_set(EulerObject *self, PyObject *value, void *UNUSED(closure)) static int Euler_order_set(EulerObject *self, PyObject *value, void *UNUSED(closure))
{ {
const char *order_str= _PyUnicode_AsString(value); const char *order_str = _PyUnicode_AsString(value);
short order= euler_order_from_string(order_str, "euler.order"); short order = euler_order_from_string(order_str, "euler.order");
if (order == -1) if (order == -1)
return -1; return -1;
self->order= order; self->order = order;
(void)BaseMath_WriteCallback(self); /* order can be written back */ (void)BaseMath_WriteCallback(self); /* order can be written back */
return 0; return 0;
} }
@@ -693,13 +693,13 @@ PyObject *Euler_CreatePyObject(float *eul, short order, int type, PyTypeObject *
{ {
EulerObject *self; EulerObject *self;
self= base_type ? (EulerObject *)base_type->tp_alloc(base_type, 0) : self = base_type ? (EulerObject *)base_type->tp_alloc(base_type, 0) :
(EulerObject *)PyObject_GC_New(EulerObject, &euler_Type); (EulerObject *)PyObject_GC_New(EulerObject, &euler_Type);
if (self) { if (self) {
/* init callbacks as NULL */ /* init callbacks as NULL */
self->cb_user= NULL; self->cb_user = NULL;
self->cb_type= self->cb_subtype= 0; self->cb_type = self->cb_subtype = 0;
if (type == Py_WRAP) { if (type == Py_WRAP) {
self->eul = eul; self->eul = eul;
@@ -720,7 +720,7 @@ PyObject *Euler_CreatePyObject(float *eul, short order, int type, PyTypeObject *
Py_FatalError("Euler(): invalid type!"); Py_FatalError("Euler(): invalid type!");
} }
self->order= order; self->order = order;
} }
return (PyObject *)self; return (PyObject *)self;
@@ -728,12 +728,12 @@ PyObject *Euler_CreatePyObject(float *eul, short order, int type, PyTypeObject *
PyObject *Euler_CreatePyObject_cb(PyObject *cb_user, short order, int cb_type, int cb_subtype) PyObject *Euler_CreatePyObject_cb(PyObject *cb_user, short order, int cb_type, int cb_subtype)
{ {
EulerObject *self= (EulerObject *)Euler_CreatePyObject(NULL, order, Py_NEW, NULL); EulerObject *self = (EulerObject *)Euler_CreatePyObject(NULL, order, Py_NEW, NULL);
if (self) { if (self) {
Py_INCREF(cb_user); Py_INCREF(cb_user);
self->cb_user= cb_user; self->cb_user = cb_user;
self->cb_type= (unsigned char)cb_type; self->cb_type = (unsigned char)cb_type;
self->cb_subtype= (unsigned char)cb_subtype; self->cb_subtype = (unsigned char)cb_subtype;
PyObject_GC_Track(self); PyObject_GC_Track(self);
} }

2
source/blender/python/mathutils/mathutils_Euler.h
View File

@@ -47,7 +47,7 @@ typedef struct {
/*struct data contains a pointer to the actual data that the /*struct data contains a pointer to the actual data that the
object uses. It can use either PyMem allocated data (which will object uses. It can use either PyMem allocated data (which will
be stored in py_data) or be a wrapper for data allocated through be stored in py_data) or be a wrapper for data allocated through
blender (stored in blend_data). This is an either/or struct not both*/ blender (stored in blend_data). This is an either/or struct not both */
//prototypes //prototypes
PyObject *Euler_CreatePyObject( float *eul, short order, int type, PyTypeObject *base_type); PyObject *Euler_CreatePyObject( float *eul, short order, int type, PyTypeObject *base_type);

258
source/blender/python/mathutils/mathutils_Matrix.c
View File

@@ -49,23 +49,23 @@ static PyObject *matrix__apply_to_copy(PyNoArgsFunction matrix_func, MatrixObjec
static PyObject *MatrixAccess_CreatePyObject(MatrixObject *matrix, const eMatrixAccess_t type); static PyObject *MatrixAccess_CreatePyObject(MatrixObject *matrix, const eMatrixAccess_t type);
/* matrix row callbacks */ /* matrix row callbacks */
int mathutils_matrix_row_cb_index= -1; int mathutils_matrix_row_cb_index = -1;
static int mathutils_matrix_vector_check(BaseMathObject *bmo) static int mathutils_matrix_vector_check(BaseMathObject *bmo)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
return BaseMath_ReadCallback(self); return BaseMath_ReadCallback(self);
} }
static int mathutils_matrix_vector_get(BaseMathObject *bmo, int row) static int mathutils_matrix_vector_get(BaseMathObject *bmo, int row)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
int col; int col;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
for (col=0; col < self->num_col; col++) { for (col = 0; col < self->num_col; col++) {
bmo->data[col] = MATRIX_ITEM(self, row, col); bmo->data[col] = MATRIX_ITEM(self, row, col);
} }
@@ -74,13 +74,13 @@ static int mathutils_matrix_vector_get(BaseMathObject *bmo, int row)
static int mathutils_matrix_vector_set(BaseMathObject *bmo, int row) static int mathutils_matrix_vector_set(BaseMathObject *bmo, int row)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
int col; int col;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
for (col=0; col < self->num_col; col++) { for (col = 0; col < self->num_col; col++) {
MATRIX_ITEM(self, row, col) = bmo->data[col]; MATRIX_ITEM(self, row, col) = bmo->data[col];
} }
@@ -90,18 +90,18 @@ static int mathutils_matrix_vector_set(BaseMathObject *bmo, int row)
static int mathutils_matrix_vector_get_index(BaseMathObject *bmo, int row, int col) static int mathutils_matrix_vector_get_index(BaseMathObject *bmo, int row, int col)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
bmo->data[col]= MATRIX_ITEM(self, row, col); bmo->data[col] = MATRIX_ITEM(self, row, col);
return 0; return 0;
} }
static int mathutils_matrix_vector_set_index(BaseMathObject *bmo, int row, int col) static int mathutils_matrix_vector_set_index(BaseMathObject *bmo, int row, int col)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
@@ -122,17 +122,17 @@ Mathutils_Callback mathutils_matrix_row_cb = {
/* matrix vector callbacks, this is so you can do matrix[i][j] = val */ /* matrix vector callbacks, this is so you can do matrix[i][j] = val */
/* matrix row callbacks */ /* matrix row callbacks */
int mathutils_matrix_col_cb_index= -1; int mathutils_matrix_col_cb_index = -1;
static int mathutils_matrix_column_check(BaseMathObject *bmo) static int mathutils_matrix_column_check(BaseMathObject *bmo)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
return BaseMath_ReadCallback(self); return BaseMath_ReadCallback(self);
} }
static int mathutils_matrix_column_get(BaseMathObject *bmo, int col) static int mathutils_matrix_column_get(BaseMathObject *bmo, int col)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
int num_row; int num_row;
int row; int row;
@@ -151,7 +151,7 @@ static int mathutils_matrix_column_get(BaseMathObject *bmo, int col)
static int mathutils_matrix_column_set(BaseMathObject *bmo, int col) static int mathutils_matrix_column_set(BaseMathObject *bmo, int col)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
int num_row; int num_row;
int row; int row;
@@ -171,18 +171,18 @@ static int mathutils_matrix_column_set(BaseMathObject *bmo, int col)
static int mathutils_matrix_column_get_index(BaseMathObject *bmo, int col, int row) static int mathutils_matrix_column_get_index(BaseMathObject *bmo, int col, int row)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
bmo->data[row]= MATRIX_ITEM(self, row, col); bmo->data[row] = MATRIX_ITEM(self, row, col);
return 0; return 0;
} }
static int mathutils_matrix_column_set_index(BaseMathObject *bmo, int col, int row) static int mathutils_matrix_column_set_index(BaseMathObject *bmo, int col, int row)
{ {
MatrixObject *self= (MatrixObject *)bmo->cb_user; MatrixObject *self = (MatrixObject *)bmo->cb_user;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
@@ -219,23 +219,23 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return Matrix_CreatePyObject(NULL, 4, 4, Py_NEW, type); return Matrix_CreatePyObject(NULL, 4, 4, Py_NEW, type);
case 1: case 1:
{ {
PyObject *arg= PyTuple_GET_ITEM(args, 0); PyObject *arg = PyTuple_GET_ITEM(args, 0);
/* Input is now as a sequence of rows so length of sequence /* Input is now as a sequence of rows so length of sequence
* is the number of rows */ * is the number of rows */
/* -1 is an error, size checks will accunt for this */ /* -1 is an error, size checks will accunt for this */
const unsigned short num_row= PySequence_Size(arg); const unsigned short num_row = PySequence_Size(arg);
if (num_row >= 2 && num_row <= 4) { if (num_row >= 2 && num_row <= 4) {
PyObject *item= PySequence_GetItem(arg, 0); PyObject *item = PySequence_GetItem(arg, 0);
/* Since each item is a row, number of items is the /* Since each item is a row, number of items is the
* same as the number of columns */ * same as the number of columns */
const unsigned short num_col= PySequence_Size(item); const unsigned short num_col = PySequence_Size(item);
Py_XDECREF(item); Py_XDECREF(item);
if (num_col >= 2 && num_col <= 4) { if (num_col >= 2 && num_col <= 4) {
/* sane row & col size, new matrix and assign as slice */ /* sane row & col size, new matrix and assign as slice */
PyObject *matrix= Matrix_CreatePyObject(NULL, num_col, num_row, Py_NEW, type); PyObject *matrix = Matrix_CreatePyObject(NULL, num_col, num_row, Py_NEW, type);
if (Matrix_ass_slice((MatrixObject *)matrix, 0, INT_MAX, arg) == 0) { if (Matrix_ass_slice((MatrixObject *)matrix, 0, INT_MAX, arg) == 0) {
return matrix; return matrix;
} }
@@ -256,8 +256,8 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
static PyObject *matrix__apply_to_copy(PyNoArgsFunction matrix_func, MatrixObject *self) static PyObject *matrix__apply_to_copy(PyNoArgsFunction matrix_func, MatrixObject *self)
{ {
PyObject *ret= Matrix_copy(self); PyObject *ret = Matrix_copy(self);
PyObject *ret_dummy= matrix_func(ret); PyObject *ret_dummy = matrix_func(ret);
if (ret_dummy) { if (ret_dummy) {
Py_DECREF(ret_dummy); Py_DECREF(ret_dummy);
return (PyObject *)ret; return (PyObject *)ret;
@@ -301,8 +301,8 @@ PyDoc_STRVAR(C_Matrix_Rotation_doc,
); );
static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args) static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
{ {
PyObject *vec= NULL; PyObject *vec = NULL;
const char *axis= NULL; const char *axis = NULL;
int matSize; int matSize;
double angle; /* use double because of precision problems at high values */ double angle; /* use double because of precision problems at high values */
float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
@@ -316,8 +316,8 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
} }
if (vec && PyUnicode_Check(vec)) { if (vec && PyUnicode_Check(vec)) {
axis= _PyUnicode_AsString((PyObject *)vec); axis = _PyUnicode_AsString((PyObject *)vec);
if (axis==NULL || axis[0]=='\0' || axis[1]!='\0' || axis[0] < 'X' || axis[0] > 'Z') { if (axis == NULL || axis[0] == '\0' || axis[1] != '\0' || axis[0] < 'X' || axis[0] > 'Z') {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"Matrix.Rotation(): " "Matrix.Rotation(): "
"3rd argument axis value must be a 3D vector " "3rd argument axis value must be a 3D vector "
@@ -326,11 +326,11 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
} }
else { else {
/* use the string */ /* use the string */
vec= NULL; vec = NULL;
} }
} }
angle= angle_wrap_rad(angle); angle = angle_wrap_rad(angle);
if (matSize != 2 && matSize != 3 && matSize != 4) { if (matSize != 2 && matSize != 3 && matSize != 4) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
@@ -361,8 +361,8 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
axis_angle_to_mat3((float (*)[3])mat, tvec, angle); axis_angle_to_mat3((float (*)[3])mat, tvec, angle);
} }
else if (matSize == 2) { else if (matSize == 2) {
const float angle_cos= cosf(angle); const float angle_cos = cosf(angle);
const float angle_sin= sinf(angle); const float angle_sin = sinf(angle);
//2D rotation matrix //2D rotation matrix
mat[0] = angle_cos; mat[0] = angle_cos;
@@ -420,7 +420,7 @@ PyDoc_STRVAR(C_Matrix_Scale_doc,
); );
static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args) static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
{ {
PyObject *vec= NULL; PyObject *vec = NULL;
int vec_size; int vec_size;
float tvec[3]; float tvec[3];
float factor; float factor;
@@ -438,7 +438,7 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
if (vec) { if (vec) {
vec_size= (matSize == 2 ? 2 : 3); vec_size = (matSize == 2 ? 2 : 3);
if (mathutils_array_parse(tvec, vec_size, vec_size, vec, "Matrix.Scale(factor, size, axis), invalid 'axis' arg") == -1) { if (mathutils_array_parse(tvec, vec_size, vec_size, vec, "Matrix.Scale(factor, size, axis), invalid 'axis' arg") == -1) {
return NULL; return NULL;
} }
@@ -526,13 +526,13 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
if (PyUnicode_Check(axis)) { //ortho projection onto cardinal plane if (PyUnicode_Check(axis)) { //ortho projection onto cardinal plane
Py_ssize_t plane_len; Py_ssize_t plane_len;
const char *plane= _PyUnicode_AsStringAndSize(axis, &plane_len); const char *plane = _PyUnicode_AsStringAndSize(axis, &plane_len);
if (matSize == 2) { if (matSize == 2) {
if (plane_len == 1 && plane[0]=='X') { if (plane_len == 1 && plane[0] == 'X') {
mat[0]= 1.0f; mat[0] = 1.0f;
} }
else if (plane_len == 1 && plane[0]=='Y') { else if (plane_len == 1 && plane[0] == 'Y') {
mat[3]= 1.0f; mat[3] = 1.0f;
} }
else { else {
PyErr_Format(PyExc_ValueError, PyErr_Format(PyExc_ValueError,
@@ -543,17 +543,17 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
} }
} }
else { else {
if (plane_len == 2 && plane[0]=='X' && plane[1]=='Y') { if (plane_len == 2 && plane[0] == 'X' && plane[1] == 'Y') {
mat[0]= 1.0f; mat[0] = 1.0f;
mat[4]= 1.0f; mat[4] = 1.0f;
} }
else if (plane_len == 2 && plane[0]=='X' && plane[1]=='Z') { else if (plane_len == 2 && plane[0] == 'X' && plane[1] == 'Z') {
mat[0]= 1.0f; mat[0] = 1.0f;
mat[8]= 1.0f; mat[8] = 1.0f;
} }
else if (plane_len == 2 && plane[0]=='Y' && plane[1]=='Z') { else if (plane_len == 2 && plane[0] == 'Y' && plane[1] == 'Z') {
mat[4]= 1.0f; mat[4] = 1.0f;
mat[8]= 1.0f; mat[8] = 1.0f;
} }
else { else {
PyErr_Format(PyExc_ValueError, PyErr_Format(PyExc_ValueError,
@@ -567,7 +567,7 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
else { else {
//arbitrary plane //arbitrary plane
int vec_size= (matSize == 2 ? 2 : 3); int vec_size = (matSize == 2 ? 2 : 3);
float tvec[4]; float tvec[4];
if (mathutils_array_parse(tvec, vec_size, vec_size, axis, if (mathutils_array_parse(tvec, vec_size, vec_size, axis,
@@ -644,9 +644,9 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
} }
if (matSize == 2) { if (matSize == 2) {
float const factor= PyFloat_AsDouble(fac); float const factor = PyFloat_AsDouble(fac);
if (factor==-1.0f && PyErr_Occurred()) { if (factor == -1.0f && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Matrix.Shear(): " "Matrix.Shear(): "
"the factor to be a float"); "the factor to be a float");
@@ -751,7 +751,7 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
/*must be 3-4 cols, 3-4 rows, square matrix*/ /* must be 3-4 cols, 3-4 rows, square matrix */
if ((self->num_row < 3) || (self->num_col < 3) || (self->num_row != self->num_col)) { if ((self->num_row < 3) || (self->num_col < 3) || (self->num_row != self->num_col)) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"Matrix.to_quat(): " "Matrix.to_quat(): "
@@ -787,8 +787,8 @@ PyDoc_STRVAR(Matrix_to_euler_doc,
); );
static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args) static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
{ {
const char *order_str= NULL; const char *order_str = NULL;
short order= EULER_ORDER_XYZ; short order = EULER_ORDER_XYZ;
float eul[3], eul_compatf[3]; float eul[3], eul_compatf[3];
EulerObject *eul_compat = NULL; EulerObject *eul_compat = NULL;
@@ -808,13 +808,13 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
copy_v3_v3(eul_compatf, eul_compat->eul); copy_v3_v3(eul_compatf, eul_compat->eul);
} }
/*must be 3-4 cols, 3-4 rows, square matrix*/ /*must be 3-4 cols, 3-4 rows, square matrix */
if (self->num_row ==3 && self->num_col ==3) { if (self->num_row ==3 && self->num_col ==3) {
mat= (float (*)[3])self->matrix; mat = (float (*)[3])self->matrix;
} }
else if (self->num_row ==4 && self->num_col ==4) { else if (self->num_row ==4 && self->num_col ==4) {
copy_m3_m4(tmat, (float (*)[4])self->matrix); copy_m3_m4(tmat, (float (*)[4])self->matrix);
mat= tmat; mat = tmat;
} }
else { else {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
@@ -824,7 +824,7 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
} }
if (order_str) { if (order_str) {
order= euler_order_from_string(order_str, "Matrix.to_euler()"); order = euler_order_from_string(order_str, "Matrix.to_euler()");
if (order == -1) if (order == -1)
return NULL; return NULL;
@@ -849,10 +849,10 @@ PyDoc_STRVAR(Matrix_resize_4x4_doc,
); );
static PyObject *Matrix_resize_4x4(MatrixObject *self) static PyObject *Matrix_resize_4x4(MatrixObject *self)
{ {
float mat[4][4]= MAT4_UNITY; float mat[4][4] = MAT4_UNITY;
int col; int col;
if (self->wrapped==Py_WRAP) { if (self->wrapped == Py_WRAP) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Matrix.resize_4x4(): " "Matrix.resize_4x4(): "
"cannot resize wrapped data - make a copy and resize that"); "cannot resize wrapped data - make a copy and resize that");
@@ -898,10 +898,10 @@ static PyObject *Matrix_to_4x4(MatrixObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
if (self->num_row==4 && self->num_col==4) { if (self->num_row == 4 && self->num_col == 4) {
return Matrix_CreatePyObject(self->matrix, 4, 4, Py_NEW, Py_TYPE(self)); return Matrix_CreatePyObject(self->matrix, 4, 4, Py_NEW, Py_TYPE(self));
} }
else if (self->num_row==3 && self->num_col==3) { else if (self->num_row == 3 && self->num_col == 3) {
float mat[4][4]; float mat[4][4];
copy_m4_m3(mat, (float (*)[3])self->matrix); copy_m4_m3(mat, (float (*)[3])self->matrix);
return Matrix_CreatePyObject((float *)mat, 4, 4, Py_NEW, Py_TYPE(self)); return Matrix_CreatePyObject((float *)mat, 4, 4, Py_NEW, Py_TYPE(self));
@@ -982,7 +982,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
/*must be 3-4 cols, 3-4 rows, square matrix*/ /*must be 3-4 cols, 3-4 rows, square matrix */
if ((self->num_row < 3) || (self->num_col < 3)) { if ((self->num_row < 3) || (self->num_col < 3)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Matrix.to_scale(): " "Matrix.to_scale(): "
@@ -1028,11 +1028,11 @@ static PyObject *Matrix_invert(MatrixObject *self)
return NULL; return NULL;
} }
/*calculate the determinant*/ /* calculate the determinant */
det = matrix_determinant_internal(self); det = matrix_determinant_internal(self);
if (det != 0) { if (det != 0) {
/*calculate the classical adjoint*/ /* calculate the classical adjoint */
if (self->num_col == 2) { if (self->num_col == 2) {
mat[0] = MATRIX_ITEM(self, 1, 1); mat[0] = MATRIX_ITEM(self, 1, 1);
mat[1] = -MATRIX_ITEM(self, 0, 1); mat[1] = -MATRIX_ITEM(self, 0, 1);
@@ -1045,11 +1045,11 @@ static PyObject *Matrix_invert(MatrixObject *self)
else if (self->num_col == 4) { else if (self->num_col == 4) {
adjoint_m4_m4((float (*)[4]) mat, (float (*)[4])self->matrix); adjoint_m4_m4((float (*)[4]) mat, (float (*)[4])self->matrix);
} }
/*divide by determinate*/ /* divide by determinate */
for (x = 0; x < (self->num_col * self->num_row); x++) { for (x = 0; x < (self->num_col * self->num_row); x++) {
mat[x] /= det; mat[x] /= det;
} }
/*set values*/ /* set values */
for (x = 0; x < self->num_col; x++) { for (x = 0; x < self->num_col; x++) {
for (y = 0; y < self->num_row; y++) { for (y = 0; y < self->num_row; y++) {
MATRIX_ITEM(self, y, x) = mat[z]; MATRIX_ITEM(self, y, x) = mat[z];
@@ -1151,7 +1151,7 @@ static PyObject *Matrix_decompose(MatrixObject *self)
mat4_to_loc_rot_size(loc, rot, size, (float (*)[4])self->matrix); mat4_to_loc_rot_size(loc, rot, size, (float (*)[4])self->matrix);
mat3_to_quat(quat, rot); mat3_to_quat(quat, rot);
ret= PyTuple_New(3); ret = PyTuple_New(3);
PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(loc, 3, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(loc, 3, Py_NEW, NULL));
PyTuple_SET_ITEM(ret, 1, Quaternion_CreatePyObject(quat, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 1, Quaternion_CreatePyObject(quat, Py_NEW, NULL));
PyTuple_SET_ITEM(ret, 2, Vector_CreatePyObject(size, 3, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 2, Vector_CreatePyObject(size, 3, Py_NEW, NULL));
@@ -1176,7 +1176,7 @@ PyDoc_STRVAR(Matrix_lerp_doc,
static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args) static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
{ {
MatrixObject *mat2 = NULL; MatrixObject *mat2 = NULL;
float fac, mat[MATRIX_MAX_DIM*MATRIX_MAX_DIM]; float fac, mat[MATRIX_MAX_DIM * MATRIX_MAX_DIM];
if (!PyArg_ParseTuple(args, "O!f:lerp", &matrix_Type, &mat2, &fac)) if (!PyArg_ParseTuple(args, "O!f:lerp", &matrix_Type, &mat2, &fac))
return NULL; return NULL;
@@ -1192,10 +1192,10 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
return NULL; return NULL;
/* TODO, different sized matrix */ /* TODO, different sized matrix */
if (self->num_col==4 && self->num_row==4) { if (self->num_col == 4 && self->num_row == 4) {
blend_m4_m4m4((float (*)[4])mat, (float (*)[4])self->matrix, (float (*)[4])mat2->matrix, fac); blend_m4_m4m4((float (*)[4])mat, (float (*)[4])self->matrix, (float (*)[4])mat2->matrix, fac);
} }
else if (self->num_col==3 && self->num_row==3) { else if (self->num_col == 3 && self->num_row == 3) {
blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->matrix, (float (*)[3])mat2->matrix, fac); blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->matrix, (float (*)[3])mat2->matrix, fac);
} }
else { else {
@@ -1360,17 +1360,17 @@ static PyObject *Matrix_copy(MatrixObject *self)
} }
/*----------------------------print object (internal)-------------*/ /*----------------------------print object (internal)-------------*/
/*print the object to screen*/ /* print the object to screen */
static PyObject *Matrix_repr(MatrixObject *self) static PyObject *Matrix_repr(MatrixObject *self)
{ {
int col, row; int col, row;
PyObject *rows[MATRIX_MAX_DIM]= {NULL}; PyObject *rows[MATRIX_MAX_DIM] = {NULL};
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
for (row = 0; row < self->num_row; row++) { for (row = 0; row < self->num_row; row++) {
rows[row]= PyTuple_New(self->num_col); rows[row] = PyTuple_New(self->num_col);
for (col = 0; col < self->num_col; col++) { for (col = 0; col < self->num_col; col++) {
PyTuple_SET_ITEM(rows[row], col, PyFloat_FromDouble(MATRIX_ITEM(self, row, col))); PyTuple_SET_ITEM(rows[row], col, PyFloat_FromDouble(MATRIX_ITEM(self, row, col)));
} }
@@ -1393,7 +1393,7 @@ static PyObject *Matrix_repr(MatrixObject *self)
return NULL; return NULL;
} }
static PyObject* Matrix_str(MatrixObject *self) static PyObject *Matrix_str(MatrixObject *self)
{ {
DynStr *ds; DynStr *ds;
@@ -1405,14 +1405,14 @@ static PyObject* Matrix_str(MatrixObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
ds= BLI_dynstr_new(); ds = BLI_dynstr_new();
/* First determine the maximum width for each column */ /* First determine the maximum width for each column */
for (col = 0; col < self->num_col; col++) { for (col = 0; col < self->num_col; col++) {
maxsize[col]= 0; maxsize[col] = 0;
for (row = 0; row < self->num_row; row++) { for (row = 0; row < self->num_row; row++) {
int size= BLI_snprintf(dummy_buf, sizeof(dummy_buf), "%.4f", MATRIX_ITEM(self, row, col)); int size = BLI_snprintf(dummy_buf, sizeof(dummy_buf), "%.4f", MATRIX_ITEM(self, row, col));
maxsize[col]= MAX2(maxsize[col], size); maxsize[col] = MAX2(maxsize[col], size);
} }
} }
@@ -1429,21 +1429,21 @@ static PyObject* Matrix_str(MatrixObject *self)
return mathutils_dynstr_to_py(ds); /* frees ds */ return mathutils_dynstr_to_py(ds); /* frees ds */
} }
static PyObject* Matrix_richcmpr(PyObject *a, PyObject *b, int op) static PyObject *Matrix_richcmpr(PyObject *a, PyObject *b, int op)
{ {
PyObject *res; PyObject *res;
int ok= -1; /* zero is true */ int ok = -1; /* zero is true */
if (MatrixObject_Check(a) && MatrixObject_Check(b)) { if (MatrixObject_Check(a) && MatrixObject_Check(b)) {
MatrixObject *matA= (MatrixObject*)a; MatrixObject *matA = (MatrixObject *)a;
MatrixObject *matB= (MatrixObject*)b; MatrixObject *matB = (MatrixObject *)b;
if (BaseMath_ReadCallback(matA) == -1 || BaseMath_ReadCallback(matB) == -1) if (BaseMath_ReadCallback(matA) == -1 || BaseMath_ReadCallback(matB) == -1)
return NULL; return NULL;
ok= ( (matA->num_row == matB->num_row) && ok = ( (matA->num_row == matB->num_row) &&
(matA->num_col == matB->num_col) && (matA->num_col == matB->num_col) &&
EXPP_VectorsAreEqual(matA->matrix, matB->matrix, (matA->num_col * matA->num_row), 1) EXPP_VectorsAreEqual(matA->matrix, matB->matrix, (matA->num_col * matA->num_row), 1)
) ? 0 : -1; ) ? 0 : -1;
} }
@@ -1470,14 +1470,14 @@ static PyObject* Matrix_richcmpr(PyObject *a, PyObject *b, int op)
/*---------------------SEQUENCE PROTOCOLS------------------------ /*---------------------SEQUENCE PROTOCOLS------------------------
----------------------------len(object)------------------------ ----------------------------len(object)------------------------
sequence length*/ sequence length */
static int Matrix_len(MatrixObject *self) static int Matrix_len(MatrixObject *self)
{ {
return (self->num_row); return (self->num_row);
} }
/*----------------------------object[]--------------------------- /*----------------------------object[]---------------------------
sequence accessor (get) sequence accessor (get)
the wrapped vector gives direct access to the matrix data*/ the wrapped vector gives direct access to the matrix data */
static PyObject *Matrix_item_row(MatrixObject *self, int row) static PyObject *Matrix_item_row(MatrixObject *self, int row)
{ {
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
@@ -1574,10 +1574,10 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
CLAMP(begin, 0, self->num_row); CLAMP(begin, 0, self->num_row);
CLAMP(end, 0, self->num_row); CLAMP(end, 0, self->num_row);
begin= MIN2(begin, end); begin = MIN2(begin, end);
tuple= PyTuple_New(end - begin); tuple = PyTuple_New(end - begin);
for (count= begin; count < end; count++) { for (count = begin; count < end; count++) {
PyTuple_SET_ITEM(tuple, count - begin, PyTuple_SET_ITEM(tuple, count - begin,
Vector_CreatePyObject_cb((PyObject *)self, self->num_col, mathutils_matrix_row_cb_index, count)); Vector_CreatePyObject_cb((PyObject *)self, self->num_col, mathutils_matrix_row_cb_index, count));
@@ -1589,7 +1589,7 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
sequence slice (set)*/ sequence slice (set)*/
static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *value) static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *value)
{ {
PyObject *value_fast= NULL; PyObject *value_fast = NULL;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
@@ -1599,12 +1599,12 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
begin = MIN2(begin, end); begin = MIN2(begin, end);
/* non list/tuple cases */ /* non list/tuple cases */
if (!(value_fast=PySequence_Fast(value, "matrix[begin:end] = value"))) { if (!(value_fast = PySequence_Fast(value, "matrix[begin:end] = value"))) {
/* PySequence_Fast sets the error */ /* PySequence_Fast sets the error */
return -1; return -1;
} }
else { else {
const int size= end - begin; const int size = end - begin;
int row, col; int row, col;
float mat[16]; float mat[16];
float vec[4]; float vec[4];
@@ -1619,10 +1619,10 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
memcpy(mat, self->matrix, self->num_col * self->num_row * sizeof(float)); memcpy(mat, self->matrix, self->num_col * self->num_row * sizeof(float));
/*parse sub items*/ /* parse sub items */
for (row = begin; row < end; row++) { for (row = begin; row < end; row++) {
/*parse each sub sequence*/ /* parse each sub sequence */
PyObject *item= PySequence_Fast_GET_ITEM(value_fast, row - begin); PyObject *item = PySequence_Fast_GET_ITEM(value_fast, row - begin);
if (mathutils_array_parse(vec, self->num_col, self->num_col, item, "matrix[begin:end] = value assignment") < 0) if (mathutils_array_parse(vec, self->num_col, self->num_col, item, "matrix[begin:end] = value assignment") < 0)
return -1; return -1;
@@ -1648,8 +1648,8 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
float mat[16]; float mat[16];
MatrixObject *mat1 = NULL, *mat2 = NULL; MatrixObject *mat1 = NULL, *mat2 = NULL;
mat1 = (MatrixObject*)m1; mat1 = (MatrixObject *)m1;
mat2 = (MatrixObject*)m2; mat2 = (MatrixObject *)m2;
if (!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) { if (!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
PyErr_Format(PyExc_TypeError, PyErr_Format(PyExc_TypeError,
@@ -1680,8 +1680,8 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
float mat[16]; float mat[16];
MatrixObject *mat1 = NULL, *mat2 = NULL; MatrixObject *mat1 = NULL, *mat2 = NULL;
mat1 = (MatrixObject*)m1; mat1 = (MatrixObject *)m1;
mat2 = (MatrixObject*)m2; mat2 = (MatrixObject *)m2;
if (!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) { if (!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
PyErr_Format(PyExc_TypeError, PyErr_Format(PyExc_TypeError,
@@ -1723,22 +1723,22 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
MatrixObject *mat1 = NULL, *mat2 = NULL; MatrixObject *mat1 = NULL, *mat2 = NULL;
if (MatrixObject_Check(m1)) { if (MatrixObject_Check(m1)) {
mat1 = (MatrixObject*)m1; mat1 = (MatrixObject *)m1;
if (BaseMath_ReadCallback(mat1) == -1) if (BaseMath_ReadCallback(mat1) == -1)
return NULL; return NULL;
} }
if (MatrixObject_Check(m2)) { if (MatrixObject_Check(m2)) {
mat2 = (MatrixObject*)m2; mat2 = (MatrixObject *)m2;
if (BaseMath_ReadCallback(mat2) == -1) if (BaseMath_ReadCallback(mat2) == -1)
return NULL; return NULL;
} }
if (mat1 && mat2) { if (mat1 && mat2) {
/*MATRIX * MATRIX*/ /* MATRIX * MATRIX */
float mat[16]= {0.0f, 0.0f, 0.0f, 0.0f, float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f}; 0.0f, 0.0f, 0.0f, 1.0f};
double dot = 0.0f; double dot = 0.0f;
int col, row, item; int col, row, item;
@@ -1763,14 +1763,14 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
} }
else if (mat2) { else if (mat2) {
/*FLOAT/INT * MATRIX */ /*FLOAT/INT * MATRIX */
if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) { if (((scalar = PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred()) == 0) {
return matrix_mul_float(mat2, scalar); return matrix_mul_float(mat2, scalar);
} }
} }
else if (mat1) { else if (mat1) {
/* MATRIX * VECTOR */ /* MATRIX * VECTOR */
if (VectorObject_Check(m2)) { if (VectorObject_Check(m2)) {
VectorObject *vec2= (VectorObject *)m2; VectorObject *vec2 = (VectorObject *)m2;
float tvec[4]; float tvec[4];
if (BaseMath_ReadCallback(vec2) == -1) if (BaseMath_ReadCallback(vec2) == -1)
return NULL; return NULL;
@@ -1788,7 +1788,7 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
return Vector_CreatePyObject(tvec, vec_size, Py_NEW, Py_TYPE(m2)); return Vector_CreatePyObject(tvec, vec_size, Py_NEW, Py_TYPE(m2));
} }
/*FLOAT/INT * MATRIX */ /*FLOAT/INT * MATRIX */
else if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) { else if (((scalar = PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred()) == 0) {
return matrix_mul_float(mat1, scalar); return matrix_mul_float(mat1, scalar);
} }
} }
@@ -1802,7 +1802,7 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name); Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name);
return NULL; return NULL;
} }
static PyObject* Matrix_inv(MatrixObject *self) static PyObject *Matrix_inv(MatrixObject *self)
{ {
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
@@ -1825,7 +1825,7 @@ static PySequenceMethods Matrix_SeqMethods = {
}; };
static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item) static PyObject *Matrix_subscript(MatrixObject *self, PyObject *item)
{ {
if (PyIndex_Check(item)) { if (PyIndex_Check(item)) {
Py_ssize_t i; Py_ssize_t i;
@@ -1862,7 +1862,7 @@ static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item)
} }
} }
static int Matrix_ass_subscript(MatrixObject* self, PyObject* item, PyObject* value) static int Matrix_ass_subscript(MatrixObject *self, PyObject *item, PyObject *value)
{ {
if (PyIndex_Check(item)) { if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
@@ -2188,16 +2188,16 @@ PyObject *Matrix_CreatePyObject(float *mat,
return NULL; return NULL;
} }
self= base_type ? (MatrixObject *)base_type->tp_alloc(base_type, 0) : self = base_type ? (MatrixObject *)base_type->tp_alloc(base_type, 0) :
(MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type); (MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type);
if (self) { if (self) {
self->num_col = num_col; self->num_col = num_col;
self->num_row = num_row; self->num_row = num_row;
/* init callbacks as NULL */ /* init callbacks as NULL */
self->cb_user= NULL; self->cb_user = NULL;
self->cb_type= self->cb_subtype= 0; self->cb_type = self->cb_subtype = 0;
if (type == Py_WRAP) { if (type == Py_WRAP) {
self->matrix = mat; self->matrix = mat;
@@ -2217,7 +2217,7 @@ PyObject *Matrix_CreatePyObject(float *mat,
} }
else if (num_col == num_row) { else if (num_col == num_row) {
/* or if no arguments are passed return identity matrix for square matrices */ /* or if no arguments are passed return identity matrix for square matrices */
PyObject *ret_dummy= Matrix_identity(self); PyObject *ret_dummy = Matrix_identity(self);
Py_DECREF(ret_dummy); Py_DECREF(ret_dummy);
} }
else { else {
@@ -2238,12 +2238,12 @@ PyObject *Matrix_CreatePyObject_cb(PyObject *cb_user,
const unsigned short num_col, const unsigned short num_row, const unsigned short num_col, const unsigned short num_row,
int cb_type, int cb_subtype) int cb_type, int cb_subtype)
{ {
MatrixObject *self= (MatrixObject *)Matrix_CreatePyObject(NULL, num_col, num_row, Py_NEW, NULL); MatrixObject *self = (MatrixObject *)Matrix_CreatePyObject(NULL, num_col, num_row, Py_NEW, NULL);
if (self) { if (self) {
Py_INCREF(cb_user); Py_INCREF(cb_user);
self->cb_user= cb_user; self->cb_user = cb_user;
self->cb_type= (unsigned char)cb_type; self->cb_type = (unsigned char)cb_type;
self->cb_subtype= (unsigned char)cb_subtype; self->cb_subtype = (unsigned char)cb_subtype;
PyObject_GC_Track(self); PyObject_GC_Track(self);
} }
return (PyObject *) self; return (PyObject *) self;
@@ -2290,9 +2290,9 @@ static int MatrixAccess_len(MatrixAccessObject *self)
self->matrix_user->num_col; self->matrix_user->num_col;
} }
static PyObject *MatrixAccess_subscript(MatrixAccessObject* self, PyObject* item) static PyObject *MatrixAccess_subscript(MatrixAccessObject *self, PyObject *item)
{ {
MatrixObject *matrix_user= self->matrix_user; MatrixObject *matrix_user = self->matrix_user;
if (PyIndex_Check(item)) { if (PyIndex_Check(item)) {
Py_ssize_t i; Py_ssize_t i;
@@ -2319,9 +2319,9 @@ static PyObject *MatrixAccess_subscript(MatrixAccessObject* self, PyObject* item
} }
} }
static int MatrixAccess_ass_subscript(MatrixAccessObject* self, PyObject* item, PyObject* value) static int MatrixAccess_ass_subscript(MatrixAccessObject *self, PyObject *item, PyObject *value)
{ {
MatrixObject *matrix_user= self->matrix_user; MatrixObject *matrix_user = self->matrix_user;
if (PyIndex_Check(item)) { if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
@@ -2385,12 +2385,12 @@ PyTypeObject matrix_access_Type = {
static PyObject *MatrixAccess_CreatePyObject(MatrixObject *matrix, const eMatrixAccess_t type) static PyObject *MatrixAccess_CreatePyObject(MatrixObject *matrix, const eMatrixAccess_t type)
{ {
MatrixAccessObject *matrix_access= (MatrixAccessObject *)PyObject_GC_New(MatrixObject, &matrix_access_Type); MatrixAccessObject *matrix_access = (MatrixAccessObject *)PyObject_GC_New(MatrixObject, &matrix_access_Type);
matrix_access->matrix_user= matrix; matrix_access->matrix_user = matrix;
Py_INCREF(matrix); Py_INCREF(matrix);
matrix_access->type= type; matrix_access->type = type;
return (PyObject *)matrix_access; return (PyObject *)matrix_access;
} }

104
source/blender/python/mathutils/mathutils_Quaternion.c
View File

@@ -51,15 +51,15 @@ static PyObject *Quaternion_to_tuple_ext(QuaternionObject *self, int ndigits)
PyObject *ret; PyObject *ret;
int i; int i;
ret= PyTuple_New(QUAT_SIZE); ret = PyTuple_New(QUAT_SIZE);
if (ndigits >= 0) { if (ndigits >= 0) {
for (i= 0; i < QUAT_SIZE; i++) { for (i = 0; i < QUAT_SIZE; i++) {
PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->quat[i], ndigits))); PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round((double)self->quat[i], ndigits)));
} }
} }
else { else {
for (i= 0; i < QUAT_SIZE; i++) { for (i = 0; i < QUAT_SIZE; i++) {
PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->quat[i])); PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->quat[i]));
} }
} }
@@ -86,8 +86,8 @@ static PyObject *Quaternion_to_euler(QuaternionObject *self, PyObject *args)
{ {
float tquat[4]; float tquat[4];
float eul[3]; float eul[3];
const char *order_str= NULL; const char *order_str = NULL;
short order= EULER_ORDER_XYZ; short order = EULER_ORDER_XYZ;
EulerObject *eul_compat = NULL; EulerObject *eul_compat = NULL;
if (!PyArg_ParseTuple(args, "|sO!:to_euler", &order_str, &euler_Type, &eul_compat)) if (!PyArg_ParseTuple(args, "|sO!:to_euler", &order_str, &euler_Type, &eul_compat))
@@ -97,7 +97,7 @@ static PyObject *Quaternion_to_euler(QuaternionObject *self, PyObject *args)
return NULL; return NULL;
if (order_str) { if (order_str) {
order= euler_order_from_string(order_str, "Matrix.to_euler()"); order = euler_order_from_string(order_str, "Matrix.to_euler()");
if (order == -1) if (order == -1)
return NULL; return NULL;
@@ -169,7 +169,7 @@ static PyObject *Quaternion_to_axis_angle(QuaternionObject *self)
quat__axis_angle_sanitize(axis, &angle); quat__axis_angle_sanitize(axis, &angle);
ret= PyTuple_New(2); ret = PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(axis, 3, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(axis, 3, Py_NEW, NULL));
PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(angle)); PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(angle));
return ret; return ret;
@@ -320,7 +320,7 @@ static PyObject *Quaternion_rotate(QuaternionObject *self, PyObject *value)
if (mathutils_any_to_rotmat(other_rmat, value, "Quaternion.rotate(value)") == -1) if (mathutils_any_to_rotmat(other_rmat, value, "Quaternion.rotate(value)") == -1)
return NULL; return NULL;
length= normalize_qt_qt(tquat, self->quat); length = normalize_qt_qt(tquat, self->quat);
quat_to_mat3(self_rmat, tquat); quat_to_mat3(self_rmat, tquat);
mul_m3_m3m3(rmat, other_rmat, self_rmat); mul_m3_m3m3(rmat, other_rmat, self_rmat);
@@ -486,9 +486,9 @@ static PyObject *Quaternion_repr(QuaternionObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
tuple= Quaternion_to_tuple_ext(self, -1); tuple = Quaternion_to_tuple_ext(self, -1);
ret= PyUnicode_FromFormat("Quaternion(%R)", tuple); ret = PyUnicode_FromFormat("Quaternion(%R)", tuple);
Py_DECREF(tuple); Py_DECREF(tuple);
return ret; return ret;
@@ -501,7 +501,7 @@ static PyObject *Quaternion_str(QuaternionObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
ds= BLI_dynstr_new(); ds = BLI_dynstr_new();
BLI_dynstr_appendf(ds, "<Quaternion (w=%.4f, x=%.4f, y=%.4f, z=%.4f)>", BLI_dynstr_appendf(ds, "<Quaternion (w=%.4f, x=%.4f, y=%.4f, z=%.4f)>",
self->quat[0], self->quat[1], self->quat[2], self->quat[3]); self->quat[0], self->quat[1], self->quat[2], self->quat[3]);
@@ -509,19 +509,19 @@ static PyObject *Quaternion_str(QuaternionObject *self)
return mathutils_dynstr_to_py(ds); /* frees ds */ return mathutils_dynstr_to_py(ds); /* frees ds */
} }
static PyObject* Quaternion_richcmpr(PyObject *a, PyObject *b, int op) static PyObject *Quaternion_richcmpr(PyObject *a, PyObject *b, int op)
{ {
PyObject *res; PyObject *res;
int ok= -1; /* zero is true */ int ok = -1; /* zero is true */
if (QuaternionObject_Check(a) && QuaternionObject_Check(b)) { if (QuaternionObject_Check(a) && QuaternionObject_Check(b)) {
QuaternionObject *quatA= (QuaternionObject *)a; QuaternionObject *quatA = (QuaternionObject *)a;
QuaternionObject *quatB= (QuaternionObject *)b; QuaternionObject *quatB = (QuaternionObject *)b;
if (BaseMath_ReadCallback(quatA) == -1 || BaseMath_ReadCallback(quatB) == -1) if (BaseMath_ReadCallback(quatA) == -1 || BaseMath_ReadCallback(quatB) == -1)
return NULL; return NULL;
ok= (EXPP_VectorsAreEqual(quatA->quat, quatB->quat, QUAT_SIZE, 1)) ? 0 : -1; ok = (EXPP_VectorsAreEqual(quatA->quat, quatB->quat, QUAT_SIZE, 1)) ? 0 : -1;
} }
switch (op) { switch (op) {
@@ -556,7 +556,7 @@ static int Quaternion_len(QuaternionObject *UNUSED(self))
//sequence accessor (get) //sequence accessor (get)
static PyObject *Quaternion_item(QuaternionObject *self, int i) static PyObject *Quaternion_item(QuaternionObject *self, int i)
{ {
if (i<0) i= QUAT_SIZE-i; if (i < 0) i = QUAT_SIZE-i;
if (i < 0 || i >= QUAT_SIZE) { if (i < 0 || i >= QUAT_SIZE) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
@@ -575,15 +575,15 @@ static PyObject *Quaternion_item(QuaternionObject *self, int i)
//sequence accessor (set) //sequence accessor (set)
static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob) static int Quaternion_ass_item(QuaternionObject *self, int i, PyObject *ob)
{ {
float scalar= (float)PyFloat_AsDouble(ob); float scalar = (float)PyFloat_AsDouble(ob);
if (scalar==-1.0f && PyErr_Occurred()) { /* parsed item not a number */ if (scalar == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"quaternion[index] = x: " "quaternion[index] = x: "
"index argument not a number"); "index argument not a number");
return -1; return -1;
} }
if (i<0) i= QUAT_SIZE-i; if (i < 0) i = QUAT_SIZE-i;
if (i < 0 || i >= QUAT_SIZE) { if (i < 0 || i >= QUAT_SIZE) {
PyErr_SetString(PyExc_IndexError, PyErr_SetString(PyExc_IndexError,
@@ -609,12 +609,12 @@ static PyObject *Quaternion_slice(QuaternionObject *self, int begin, int end)
return NULL; return NULL;
CLAMP(begin, 0, QUAT_SIZE); CLAMP(begin, 0, QUAT_SIZE);
if (end<0) end= (QUAT_SIZE + 1) + end; if (end < 0) end = (QUAT_SIZE + 1) + end;
CLAMP(end, 0, QUAT_SIZE); CLAMP(end, 0, QUAT_SIZE);
begin= MIN2(begin, end); begin = MIN2(begin, end);
tuple= PyTuple_New(end - begin); tuple = PyTuple_New(end - begin);
for (count= begin; count < end; count++) { for (count = begin; count < end; count++) {
PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->quat[count])); PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->quat[count]));
} }
@@ -631,11 +631,11 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb
return -1; return -1;
CLAMP(begin, 0, QUAT_SIZE); CLAMP(begin, 0, QUAT_SIZE);
if (end<0) end= (QUAT_SIZE + 1) + end; if (end < 0) end = (QUAT_SIZE + 1) + end;
CLAMP(end, 0, QUAT_SIZE); CLAMP(end, 0, QUAT_SIZE);
begin = MIN2(begin, end); begin = MIN2(begin, end);
if ((size=mathutils_array_parse(quat, 0, QUAT_SIZE, seq, "mathutils.Quaternion[begin:end] = []")) == -1) if ((size = mathutils_array_parse(quat, 0, QUAT_SIZE, seq, "mathutils.Quaternion[begin:end] = []")) == -1)
return -1; return -1;
if (size != (end - begin)) { if (size != (end - begin)) {
@@ -646,7 +646,7 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb
} }
/* parsed well - now set in vector */ /* parsed well - now set in vector */
for (i= 0; i < size; i++) for (i = 0; i < size; i++)
self->quat[begin + i] = quat[i]; self->quat[begin + i] = quat[i];
(void)BaseMath_WriteCallback(self); (void)BaseMath_WriteCallback(self);
@@ -809,7 +809,7 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
} }
/* the only case this can happen (for a supported type is "FLOAT*QUAT") */ /* the only case this can happen (for a supported type is "FLOAT*QUAT") */
else if (quat2) { /* FLOAT*QUAT */ else if (quat2) { /* FLOAT*QUAT */
if (((scalar= PyFloat_AsDouble(q1)) == -1.0f && PyErr_Occurred())==0) { if (((scalar = PyFloat_AsDouble(q1)) == -1.0f && PyErr_Occurred()) == 0) {
return quat_mul_float(quat2, scalar); return quat_mul_float(quat2, scalar);
} }
} }
@@ -836,7 +836,7 @@ static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
return Vector_CreatePyObject(tvec, 3, Py_NEW, Py_TYPE(vec2)); return Vector_CreatePyObject(tvec, 3, Py_NEW, Py_TYPE(vec2));
} }
/* QUAT * FLOAT */ /* QUAT * FLOAT */
else if ((((scalar= PyFloat_AsDouble(q2)) == -1.0f && PyErr_Occurred())==0)) { else if ((((scalar = PyFloat_AsDouble(q2)) == -1.0f && PyErr_Occurred()) == 0)) {
return quat_mul_float(quat1, scalar); return quat_mul_float(quat1, scalar);
} }
} }
@@ -950,7 +950,7 @@ static PyObject *Quaternion_angle_get(QuaternionObject *self, void *UNUSED(closu
normalize_qt_qt(tquat, self->quat); normalize_qt_qt(tquat, self->quat);
angle= 2.0f * saacos(tquat[0]); angle = 2.0f * saacos(tquat[0]);
quat__axis_angle_sanitize(NULL, &angle); quat__axis_angle_sanitize(NULL, &angle);
@@ -968,18 +968,18 @@ static int Quaternion_angle_set(QuaternionObject *self, PyObject *value, void *U
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
len= normalize_qt_qt(tquat, self->quat); len = normalize_qt_qt(tquat, self->quat);
quat_to_axis_angle(axis, &angle_dummy, tquat); quat_to_axis_angle(axis, &angle_dummy, tquat);
angle= PyFloat_AsDouble(value); angle = PyFloat_AsDouble(value);
if (angle==-1.0f && PyErr_Occurred()) { /* parsed item not a number */ if (angle == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Quaternion.angle = value: float expected"); "Quaternion.angle = value: float expected");
return -1; return -1;
} }
angle= angle_wrap_rad(angle); angle = angle_wrap_rad(angle);
quat__axis_angle_sanitize(axis, &angle); quat__axis_angle_sanitize(axis, &angle);
@@ -1021,7 +1021,7 @@ static int Quaternion_axis_vector_set(QuaternionObject *self, PyObject *value, v
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
len= normalize_qt_qt(tquat, self->quat); len = normalize_qt_qt(tquat, self->quat);
quat_to_axis_angle(axis, &angle, tquat); /* axis value is unused */ quat_to_axis_angle(axis, &angle, tquat); /* axis value is unused */
if (mathutils_array_parse(axis, 3, 3, value, "quat.axis = other") == -1) if (mathutils_array_parse(axis, 3, 3, value, "quat.axis = other") == -1)
@@ -1041,9 +1041,9 @@ static int Quaternion_axis_vector_set(QuaternionObject *self, PyObject *value, v
//----------------------------------mathutils.Quaternion() -------------- //----------------------------------mathutils.Quaternion() --------------
static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kwds) static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{ {
PyObject *seq= NULL; PyObject *seq = NULL;
double angle = 0.0f; double angle = 0.0f;
float quat[QUAT_SIZE]= {0.0f, 0.0f, 0.0f, 0.0f}; float quat[QUAT_SIZE] = {0.0f, 0.0f, 0.0f, 0.0f};
if (kwds && PyDict_Size(kwds)) { if (kwds && PyDict_Size(kwds)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
@@ -1065,7 +1065,7 @@ static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kw
case 2: case 2:
if (mathutils_array_parse(quat, 3, 3, seq, "mathutils.Quaternion()") == -1) if (mathutils_array_parse(quat, 3, 3, seq, "mathutils.Quaternion()") == -1)
return NULL; return NULL;
angle= angle_wrap_rad(angle); /* clamp because of precision issues */ angle = angle_wrap_rad(angle); /* clamp because of precision issues */
axis_angle_to_quat(quat, quat, angle); axis_angle_to_quat(quat, quat, angle);
break; break;
/* PyArg_ParseTuple assures no more then 2 */ /* PyArg_ParseTuple assures no more then 2 */
@@ -1075,8 +1075,8 @@ static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kw
static PyObject *quat__apply_to_copy(PyNoArgsFunction quat_func, QuaternionObject *self) static PyObject *quat__apply_to_copy(PyNoArgsFunction quat_func, QuaternionObject *self)
{ {
PyObject *ret= Quaternion_copy(self); PyObject *ret = Quaternion_copy(self);
PyObject *ret_dummy= quat_func(ret); PyObject *ret_dummy = quat_func(ret);
if (ret_dummy) { if (ret_dummy) {
Py_DECREF(ret_dummy); Py_DECREF(ret_dummy);
return ret; return ret;
@@ -1095,9 +1095,9 @@ static void quat__axis_angle_sanitize(float axis[3], float *angle)
!finite(axis[1]) || !finite(axis[1]) ||
!finite(axis[2])) !finite(axis[2]))
{ {
axis[0]= 1.0f; axis[0] = 1.0f;
axis[1]= 0.0f; axis[1] = 0.0f;
axis[2]= 0.0f; axis[2] = 0.0f;
} }
else if ( EXPP_FloatsAreEqual(axis[0], 0.0f, 10) && else if ( EXPP_FloatsAreEqual(axis[0], 0.0f, 10) &&
EXPP_FloatsAreEqual(axis[1], 0.0f, 10) && EXPP_FloatsAreEqual(axis[1], 0.0f, 10) &&
@@ -1109,7 +1109,7 @@ static void quat__axis_angle_sanitize(float axis[3], float *angle)
if (angle) { if (angle) {
if (!finite(*angle)) { if (!finite(*angle)) {
*angle= 0.0f; *angle = 0.0f;
} }
} }
} }
@@ -1225,13 +1225,13 @@ PyObject *Quaternion_CreatePyObject(float *quat, int type, PyTypeObject *base_ty
{ {
QuaternionObject *self; QuaternionObject *self;
self= base_type ? (QuaternionObject *)base_type->tp_alloc(base_type, 0) : self = base_type ? (QuaternionObject *)base_type->tp_alloc(base_type, 0) :
(QuaternionObject *)PyObject_GC_New(QuaternionObject, &quaternion_Type); (QuaternionObject *)PyObject_GC_New(QuaternionObject, &quaternion_Type);
if (self) { if (self) {
/* init callbacks as NULL */ /* init callbacks as NULL */
self->cb_user= NULL; self->cb_user = NULL;
self->cb_type= self->cb_subtype= 0; self->cb_type = self->cb_subtype = 0;
if (type == Py_WRAP) { if (type == Py_WRAP) {
self->quat = quat; self->quat = quat;
@@ -1256,12 +1256,12 @@ PyObject *Quaternion_CreatePyObject(float *quat, int type, PyTypeObject *base_ty
PyObject *Quaternion_CreatePyObject_cb(PyObject *cb_user, int cb_type, int cb_subtype) PyObject *Quaternion_CreatePyObject_cb(PyObject *cb_user, int cb_type, int cb_subtype)
{ {
QuaternionObject *self= (QuaternionObject *)Quaternion_CreatePyObject(NULL, Py_NEW, NULL); QuaternionObject *self = (QuaternionObject *)Quaternion_CreatePyObject(NULL, Py_NEW, NULL);
if (self) { if (self) {
Py_INCREF(cb_user); Py_INCREF(cb_user);
self->cb_user= cb_user; self->cb_user = cb_user;
self->cb_type= (unsigned char)cb_type; self->cb_type = (unsigned char)cb_type;
self->cb_subtype= (unsigned char)cb_subtype; self->cb_subtype = (unsigned char)cb_subtype;
PyObject_GC_Track(self); PyObject_GC_Track(self);
} }

201
source/blender/python/mathutils/mathutils_Vector.c
View File

@@ -55,12 +55,12 @@ static int row_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject *v
*/ */
static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED(kwds)) static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED(kwds))
{ {
float *vec= NULL; float *vec = NULL;
int size= 3; /* default to a 3D vector */ int size = 3; /* default to a 3D vector */
switch (PyTuple_GET_SIZE(args)) { switch (PyTuple_GET_SIZE(args)) {
case 0: case 0:
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -72,7 +72,7 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED
fill_vn_fl(vec, size, 0.0f); fill_vn_fl(vec, size, 0.0f);
break; break;
case 1: case 1:
if ((size=mathutils_array_parse_alloc(&vec, 2, PyTuple_GET_ITEM(args, 0), "mathutils.Vector()")) == -1) { if ((size = mathutils_array_parse_alloc(&vec, 2, PyTuple_GET_ITEM(args, 0), "mathutils.Vector()")) == -1) {
if (vec) { if (vec) {
PyMem_Free(vec); PyMem_Free(vec);
} }
@@ -90,8 +90,8 @@ static PyObject *Vector_new(PyTypeObject *type, PyObject *args, PyObject *UNUSED
static PyObject *vec__apply_to_copy(PyNoArgsFunction vec_func, VectorObject *self) static PyObject *vec__apply_to_copy(PyNoArgsFunction vec_func, VectorObject *self)
{ {
PyObject *ret= Vector_copy(self); PyObject *ret = Vector_copy(self);
PyObject *ret_dummy= vec_func(ret); PyObject *ret_dummy = vec_func(ret);
if (ret_dummy) { if (ret_dummy) {
Py_DECREF(ret_dummy); Py_DECREF(ret_dummy);
return (PyObject *)ret; return (PyObject *)ret;
@@ -117,7 +117,7 @@ static PyObject *C_Vector_Fill(PyObject *cls, PyObject *args)
{ {
float *vec; float *vec;
int size; int size;
float fill= 0.0f; float fill = 0.0f;
if (!PyArg_ParseTuple(args, "i|f:Vector.Fill", &size, &fill)) { if (!PyArg_ParseTuple(args, "i|f:Vector.Fill", &size, &fill)) {
return NULL; return NULL;
@@ -129,7 +129,7 @@ static PyObject *C_Vector_Fill(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -159,8 +159,8 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
{ {
float *vec; float *vec;
int stop, size; int stop, size;
int start= 0; int start = 0;
int step= 1; int step = 1;
if (!PyArg_ParseTuple(args, "i|ii:Vector.Range", &start, &stop, &step)) { if (!PyArg_ParseTuple(args, "i|ii:Vector.Range", &start, &stop, &step)) {
return NULL; return NULL;
@@ -169,7 +169,7 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
switch (PyTuple_GET_SIZE(args)) { switch (PyTuple_GET_SIZE(args)) {
case 1: case 1:
size = start; size = start;
start= 0; start = 0;
break; break;
case 2: case 2:
if (start >= stop) { if (start >= stop) {
@@ -179,7 +179,7 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
size= stop - start; size = stop - start;
break; break;
default: default:
if (start >= stop) { if (start >= stop) {
@@ -188,13 +188,13 @@ static PyObject *C_Vector_Range(PyObject *cls, PyObject *args)
"than the stop value"); "than the stop value");
return NULL; return NULL;
} }
size= (stop - start)/step; size = (stop - start)/step;
if (size%step) if (size%step)
size++; size++;
break; break;
} }
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -236,9 +236,9 @@ static PyObject *C_Vector_Linspace(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
step= (end - start)/(float)(size-1); step = (end - start)/(float)(size-1);
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -265,7 +265,7 @@ PyDoc_STRVAR(C_Vector_Repeat_doc,
static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args) static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
{ {
float *vec; float *vec;
float *iter_vec= NULL; float *iter_vec = NULL;
int i, size, value_size; int i, size, value_size;
PyObject *value; PyObject *value;
@@ -279,7 +279,7 @@ static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
if ((value_size=mathutils_array_parse_alloc(&iter_vec, 2, value, "Vector.Repeat(vector, size), invalid 'vector' arg")) == -1) { if ((value_size = mathutils_array_parse_alloc(&iter_vec, 2, value, "Vector.Repeat(vector, size), invalid 'vector' arg")) == -1) {
PyMem_Free(iter_vec); PyMem_Free(iter_vec);
return NULL; return NULL;
} }
@@ -291,7 +291,7 @@ static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -300,9 +300,9 @@ static PyObject *C_Vector_Repeat(PyObject *cls, PyObject *args)
return NULL; return NULL;
} }
i= 0; i = 0;
while (i < size) { while (i < size) {
vec[i]= iter_vec[i % value_size]; vec[i] = iter_vec[i % value_size];
i++; i++;
} }
@@ -373,7 +373,7 @@ static PyObject *Vector_resize(VectorObject *self, PyObject *value)
{ {
int size; int size;
if (self->wrapped==Py_WRAP) { if (self->wrapped == Py_WRAP) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Vector.resize(): " "Vector.resize(): "
"cannot resize wrapped data - only python vectors"); "cannot resize wrapped data - only python vectors");
@@ -441,7 +441,7 @@ static PyObject *Vector_resized(VectorObject *self, PyObject *value)
return NULL; return NULL;
} }
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -466,7 +466,7 @@ PyDoc_STRVAR(Vector_resize_2d_doc,
); );
static PyObject *Vector_resize_2d(VectorObject *self) static PyObject *Vector_resize_2d(VectorObject *self)
{ {
if (self->wrapped==Py_WRAP) { if (self->wrapped == Py_WRAP) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Vector.resize_2d(): " "Vector.resize_2d(): "
"cannot resize wrapped data - only python vectors"); "cannot resize wrapped data - only python vectors");
@@ -501,7 +501,7 @@ PyDoc_STRVAR(Vector_resize_3d_doc,
); );
static PyObject *Vector_resize_3d(VectorObject *self) static PyObject *Vector_resize_3d(VectorObject *self)
{ {
if (self->wrapped==Py_WRAP) { if (self->wrapped == Py_WRAP) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Vector.resize_3d(): " "Vector.resize_3d(): "
"cannot resize wrapped data - only python vectors"); "cannot resize wrapped data - only python vectors");
@@ -539,7 +539,7 @@ PyDoc_STRVAR(Vector_resize_4d_doc,
); );
static PyObject *Vector_resize_4d(VectorObject *self) static PyObject *Vector_resize_4d(VectorObject *self)
{ {
if (self->wrapped==Py_WRAP) { if (self->wrapped == Py_WRAP) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Vector.resize_4d(): " "Vector.resize_4d(): "
"cannot resize wrapped data - only python vectors"); "cannot resize wrapped data - only python vectors");
@@ -595,7 +595,7 @@ PyDoc_STRVAR(Vector_to_3d_doc,
); );
static PyObject *Vector_to_3d(VectorObject *self) static PyObject *Vector_to_3d(VectorObject *self)
{ {
float tvec[3]= {0.0f}; float tvec[3] = {0.0f};
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
@@ -613,7 +613,7 @@ PyDoc_STRVAR(Vector_to_4d_doc,
); );
static PyObject *Vector_to_4d(VectorObject *self) static PyObject *Vector_to_4d(VectorObject *self)
{ {
float tvec[4]= {0.0f, 0.0f, 0.0f, 1.0f}; float tvec[4] = {0.0f, 0.0f, 0.0f, 1.0f};
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
@@ -638,7 +638,7 @@ static PyObject *Vector_to_tuple_ext(VectorObject *self, int ndigits)
PyObject *ret; PyObject *ret;
int i; int i;
ret= PyTuple_New(self->size); ret = PyTuple_New(self->size);
if (ndigits >= 0) { if (ndigits >= 0) {
for (i = 0; i < self->size; i++) { for (i = 0; i < self->size; i++) {
@@ -656,7 +656,7 @@ static PyObject *Vector_to_tuple_ext(VectorObject *self, int ndigits)
static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args) static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args)
{ {
int ndigits= 0; int ndigits = 0;
if (!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits)) if (!PyArg_ParseTuple(args, "|i:to_tuple", &ndigits))
return NULL; return NULL;
@@ -668,8 +668,8 @@ static PyObject *Vector_to_tuple(VectorObject *self, PyObject *args)
return NULL; return NULL;
} }
if (PyTuple_GET_SIZE(args)==0) if (PyTuple_GET_SIZE(args) == 0)
ndigits= -1; ndigits = -1;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
@@ -709,7 +709,7 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
return NULL; return NULL;
if (strack) { if (strack) {
const char *axis_err_msg= "only X, -X, Y, -Y, Z or -Z for track axis"; const char *axis_err_msg = "only X, -X, Y, -Y, Z or -Z for track axis";
if (strlen(strack) == 2) { if (strlen(strack) == 2) {
if (strack[0] == '-') { if (strack[0] == '-') {
@@ -757,7 +757,7 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
} }
if (sup) { if (sup) {
const char *axis_err_msg= "only X, Y or Z for up axis"; const char *axis_err_msg = "only X, Y or Z for up axis";
if (strlen(sup) == 1) { if (strlen(sup) == 1) {
switch (*sup) { switch (*sup) {
case 'X': case 'X':
@@ -821,7 +821,7 @@ static PyObject *Vector_reflect(VectorObject *self, PyObject *value)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
if ((value_size= mathutils_array_parse(tvec, 2, 4, value, "Vector.reflect(other), invalid 'other' arg")) == -1) if ((value_size = mathutils_array_parse(tvec, 2, 4, value, "Vector.reflect(other), invalid 'other' arg")) == -1)
return NULL; return NULL;
if (self->size < 2 || self->size > 4) { if (self->size < 2 || self->size > 4) {
@@ -875,7 +875,7 @@ static PyObject *Vector_cross(VectorObject *self, PyObject *value)
return NULL; return NULL;
} }
ret= (VectorObject *)Vector_CreatePyObject(NULL, 3, Py_NEW, Py_TYPE(self)); ret = (VectorObject *)Vector_CreatePyObject(NULL, 3, Py_NEW, Py_TYPE(self));
cross_v3_v3v3(ret->vec, self->vec, tvec); cross_v3_v3v3(ret->vec, self->vec, tvec);
return (PyObject *)ret; return (PyObject *)ret;
} }
@@ -925,12 +925,12 @@ PyDoc_STRVAR(Vector_angle_doc,
); );
static PyObject *Vector_angle(VectorObject *self, PyObject *args) static PyObject *Vector_angle(VectorObject *self, PyObject *args)
{ {
const int size= MIN2(self->size, 3); /* 4D angle makes no sense */ const int size = MIN2(self->size, 3); /* 4D angle makes no sense */
float tvec[MAX_DIMENSIONS]; float tvec[MAX_DIMENSIONS];
PyObject *value; PyObject *value;
double dot= 0.0f, dot_self= 0.0f, dot_other= 0.0f; double dot = 0.0f, dot_self = 0.0f, dot_other = 0.0f;
int x; int x;
PyObject *fallback= NULL; PyObject *fallback = NULL;
if (!PyArg_ParseTuple(args, "O|O:angle", &value, &fallback)) if (!PyArg_ParseTuple(args, "O|O:angle", &value, &fallback))
return NULL; return NULL;
@@ -1022,7 +1022,7 @@ PyDoc_STRVAR(Vector_project_doc,
); );
static PyObject *Vector_project(VectorObject *self, PyObject *value) static PyObject *Vector_project(VectorObject *self, PyObject *value)
{ {
const int size= self->size; const int size = self->size;
float tvec[MAX_DIMENSIONS]; float tvec[MAX_DIMENSIONS];
float vec[MAX_DIMENSIONS]; float vec[MAX_DIMENSIONS];
double dot = 0.0f, dot2 = 0.0f; double dot = 0.0f, dot2 = 0.0f;
@@ -1070,8 +1070,8 @@ PyDoc_STRVAR(Vector_lerp_doc,
); );
static PyObject *Vector_lerp(VectorObject *self, PyObject *args) static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
{ {
const int size= self->size; const int size = self->size;
PyObject *value= NULL; PyObject *value = NULL;
float fac, ifac; float fac, ifac;
float *tvec, *vec; float *tvec, *vec;
int x; int x;
@@ -1087,7 +1087,7 @@ static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
goto cleanup; goto cleanup;
} }
vec= PyMem_Malloc(size * sizeof(float)); vec = PyMem_Malloc(size * sizeof(float));
if (vec == NULL) { if (vec == NULL) {
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
"Vector.lerp(): " "Vector.lerp(): "
@@ -1095,7 +1095,7 @@ static PyObject *Vector_lerp(VectorObject *self, PyObject *args)
return NULL; return NULL;
} }
ifac= 1.0f - fac; ifac = 1.0f - fac;
for (x = 0; x < size; x++) { for (x = 0; x < size; x++) {
vec[x] = (ifac * self->vec[x]) + (fac * tvec[x]); vec[x] = (ifac * self->vec[x]) + (fac * tvec[x]);
@@ -1166,8 +1166,8 @@ static PyObject *Vector_repr(VectorObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
tuple= Vector_to_tuple_ext(self, -1); tuple = Vector_to_tuple_ext(self, -1);
ret= PyUnicode_FromFormat("Vector(%R)", tuple); ret = PyUnicode_FromFormat("Vector(%R)", tuple);
Py_DECREF(tuple); Py_DECREF(tuple);
return ret; return ret;
} }
@@ -1181,7 +1181,7 @@ static PyObject *Vector_str(VectorObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
ds= BLI_dynstr_new(); ds = BLI_dynstr_new();
BLI_dynstr_append(ds, "<Vector ("); BLI_dynstr_append(ds, "<Vector (");
@@ -1204,7 +1204,7 @@ static int Vector_len(VectorObject *self)
/* sequence accessor (get): vector[index] */ /* sequence accessor (get): vector[index] */
static PyObject *vector_item_internal(VectorObject *self, int i, const int is_attr) static PyObject *vector_item_internal(VectorObject *self, int i, const int is_attr)
{ {
if (i<0) i= self->size-i; if (i < 0) i = self->size-i;
if (i < 0 || i >= self->size) { if (i < 0 || i >= self->size) {
if (is_attr) { if (is_attr) {
@@ -1233,14 +1233,14 @@ static PyObject *Vector_item(VectorObject *self, int i)
static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, const int is_attr) static int vector_ass_item_internal(VectorObject *self, int i, PyObject *value, const int is_attr)
{ {
float scalar; float scalar;
if ((scalar=PyFloat_AsDouble(value))==-1.0f && PyErr_Occurred()) { /* parsed item not a number */ if ((scalar = PyFloat_AsDouble(value)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"vector[index] = x: " "vector[index] = x: "
"index argument not a number"); "index argument not a number");
return -1; return -1;
} }
if (i<0) i= self->size-i; if (i < 0) i = self->size-i;
if (i < 0 || i >= self->size) { if (i < 0 || i >= self->size) {
if (is_attr) { if (is_attr) {
@@ -1277,11 +1277,11 @@ static PyObject *Vector_slice(VectorObject *self, int begin, int end)
return NULL; return NULL;
CLAMP(begin, 0, self->size); CLAMP(begin, 0, self->size);
if (end<0) end= self->size+end+1; if (end < 0) end = self->size + end + 1;
CLAMP(end, 0, self->size); CLAMP(end, 0, self->size);
begin= MIN2(begin, end); begin = MIN2(begin, end);
tuple= PyTuple_New(end - begin); tuple = PyTuple_New(end - begin);
for (count = begin; count < end; count++) { for (count = begin; count < end; count++) {
PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->vec[count])); PyTuple_SET_ITEM(tuple, count - begin, PyFloat_FromDouble(self->vec[count]));
} }
@@ -1292,7 +1292,7 @@ static PyObject *Vector_slice(VectorObject *self, int begin, int end)
static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *seq) static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *seq)
{ {
int size = 0; int size = 0;
float *vec= NULL; float *vec = NULL;
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
@@ -1333,7 +1333,7 @@ cleanup:
static PyObject *Vector_add(PyObject *v1, PyObject *v2) static PyObject *Vector_add(PyObject *v1, PyObject *v2)
{ {
VectorObject *vec1 = NULL, *vec2 = NULL; VectorObject *vec1 = NULL, *vec2 = NULL;
float *vec= NULL; float *vec = NULL;
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) { if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
PyErr_Format(PyExc_AttributeError, PyErr_Format(PyExc_AttributeError,
@@ -1356,7 +1356,7 @@ static PyObject *Vector_add(PyObject *v1, PyObject *v2)
return NULL; return NULL;
} }
vec= PyMem_Malloc(vec1->size * sizeof(float)); vec = PyMem_Malloc(vec1->size * sizeof(float));
if (vec == NULL) { /*allocation failure*/ if (vec == NULL) { /*allocation failure*/
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -1428,7 +1428,7 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
return NULL; return NULL;
} }
vec= PyMem_Malloc(vec1->size * sizeof(float)); vec = PyMem_Malloc(vec1->size * sizeof(float));
if (vec == NULL) { /*allocation failure*/ if (vec == NULL) { /*allocation failure*/
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -1445,7 +1445,7 @@ static PyObject *Vector_sub(PyObject *v1, PyObject *v2)
/* subtraction in-place: obj -= obj */ /* subtraction in-place: obj -= obj */
static PyObject *Vector_isub(PyObject *v1, PyObject *v2) static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
{ {
VectorObject *vec1= NULL, *vec2= NULL; VectorObject *vec1 = NULL, *vec2 = NULL;
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) { if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
PyErr_Format(PyExc_AttributeError, PyErr_Format(PyExc_AttributeError,
@@ -1486,7 +1486,7 @@ static PyObject *Vector_isub(PyObject *v1, PyObject *v2)
* note: vector/matrix multiplication IS NOT COMMUTATIVE!!!! * note: vector/matrix multiplication IS NOT COMMUTATIVE!!!!
* note: assume read callbacks have been done first. * note: assume read callbacks have been done first.
*/ */
int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject* vec, MatrixObject * mat) int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject *vec, MatrixObject *mat)
{ {
float vec_cpy[MAX_DIMENSIONS]; float vec_cpy[MAX_DIMENSIONS];
double dot = 0.0f; double dot = 0.0f;
@@ -1522,8 +1522,7 @@ int column_vector_multiplication(float r_vec[MAX_DIMENSIONS], VectorObject* vec,
static PyObject *vector_mul_float(VectorObject *vec, const float scalar) static PyObject *vector_mul_float(VectorObject *vec, const float scalar)
{ {
float *tvec= NULL; float *tvec = PyMem_Malloc(vec->size * sizeof(float));
tvec= PyMem_Malloc(vec->size * sizeof(float));
if (tvec == NULL) { /*allocation failure*/ if (tvec == NULL) { /*allocation failure*/
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -1543,12 +1542,12 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
int vec_size; int vec_size;
if VectorObject_Check(v1) { if VectorObject_Check(v1) {
vec1= (VectorObject *)v1; vec1 = (VectorObject *)v1;
if (BaseMath_ReadCallback(vec1) == -1) if (BaseMath_ReadCallback(vec1) == -1)
return NULL; return NULL;
} }
if VectorObject_Check(v2) { if VectorObject_Check(v2) {
vec2= (VectorObject *)v2; vec2 = (VectorObject *)v2;
if (BaseMath_ReadCallback(vec2) == -1) if (BaseMath_ReadCallback(vec2) == -1)
return NULL; return NULL;
} }
@@ -1614,12 +1613,12 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
#endif #endif
/* ------ to be removed ------*/ /* ------ to be removed ------*/
} }
else if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* VEC * FLOAT */ else if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* VEC * FLOAT */
return vector_mul_float(vec1, scalar); return vector_mul_float(vec1, scalar);
} }
} }
else if (vec2) { else if (vec2) {
if (((scalar= PyFloat_AsDouble(v1)) == -1.0f && PyErr_Occurred())==0) { /* FLOAT * VEC */ if (((scalar = PyFloat_AsDouble(v1)) == -1.0f && PyErr_Occurred()) == 0) { /* FLOAT * VEC */
return vector_mul_float(vec2, scalar); return vector_mul_float(vec2, scalar);
} }
} }
@@ -1693,7 +1692,7 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
#endif #endif
/* ------ to be removed ------*/ /* ------ to be removed ------*/
} }
else if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* VEC *= FLOAT */ else if (((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) == 0) { /* VEC *= FLOAT */
mul_vn_fl(vec->vec, vec->size, scalar); mul_vn_fl(vec->vec, vec->size, scalar);
} }
else { else {
@@ -1712,7 +1711,7 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
/* divid: obj / obj */ /* divid: obj / obj */
static PyObject *Vector_div(PyObject *v1, PyObject *v2) static PyObject *Vector_div(PyObject *v1, PyObject *v2)
{ {
float *vec= NULL, scalar; float *vec = NULL, scalar;
VectorObject *vec1 = NULL; VectorObject *vec1 = NULL;
if (!VectorObject_Check(v1)) { /* not a vector */ if (!VectorObject_Check(v1)) { /* not a vector */
@@ -1726,21 +1725,21 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2)
if (BaseMath_ReadCallback(vec1) == -1) if (BaseMath_ReadCallback(vec1) == -1)
return NULL; return NULL;
if ((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ if ((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Vector division: " "Vector division: "
"Vector must be divided by a float"); "Vector must be divided by a float");
return NULL; return NULL;
} }
if (scalar==0.0f) { if (scalar == 0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, PyErr_SetString(PyExc_ZeroDivisionError,
"Vector division: " "Vector division: "
"divide by zero error"); "divide by zero error");
return NULL; return NULL;
} }
vec= PyMem_Malloc(vec1->size * sizeof(float)); vec = PyMem_Malloc(vec1->size * sizeof(float));
if (vec == NULL) { /*allocation failure*/ if (vec == NULL) { /*allocation failure*/
PyErr_SetString(PyExc_MemoryError, PyErr_SetString(PyExc_MemoryError,
@@ -1749,7 +1748,7 @@ static PyObject *Vector_div(PyObject *v1, PyObject *v2)
return NULL; return NULL;
} }
mul_vn_vn_fl(vec, vec1->vec, vec1->size, 1.0f/scalar); mul_vn_vn_fl(vec, vec1->vec, vec1->size, 1.0f / scalar);
return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1)); return Vector_CreatePyObject_alloc(vec, vec1->size, Py_TYPE(v1));
} }
@@ -1763,21 +1762,21 @@ static PyObject *Vector_idiv(PyObject *v1, PyObject *v2)
if (BaseMath_ReadCallback(vec1) == -1) if (BaseMath_ReadCallback(vec1) == -1)
return NULL; return NULL;
if ((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */ if ((scalar = PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"Vector division: " "Vector division: "
"Vector must be divided by a float"); "Vector must be divided by a float");
return NULL; return NULL;
} }
if (scalar==0.0f) { if (scalar == 0.0f) {
PyErr_SetString(PyExc_ZeroDivisionError, PyErr_SetString(PyExc_ZeroDivisionError,
"Vector division: " "Vector division: "
"divide by zero error"); "divide by zero error");
return NULL; return NULL;
} }
mul_vn_fl(vec1->vec, vec1->size, 1.0f/scalar); mul_vn_fl(vec1->vec, vec1->size, 1.0f / scalar);
(void)BaseMath_WriteCallback(vec1); (void)BaseMath_WriteCallback(vec1);
@@ -1794,7 +1793,7 @@ static PyObject *Vector_neg(VectorObject *self)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return NULL; return NULL;
tvec= PyMem_Malloc(self->size * sizeof(float)); tvec = PyMem_Malloc(self->size * sizeof(float));
negate_vn_vn(tvec, self->vec, self->size); negate_vn_vn(tvec, self->vec, self->size);
return Vector_CreatePyObject_alloc(tvec, self->size, Py_TYPE(self)); return Vector_CreatePyObject_alloc(tvec, self->size, Py_TYPE(self));
} }
@@ -1812,7 +1811,7 @@ static double vec_magnitude_nosqrt(float *data, int size)
/*------------------------tp_richcmpr /*------------------------tp_richcmpr
returns -1 execption, 0 false, 1 true */ returns -1 execption, 0 false, 1 true */
static PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type) static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
{ {
VectorObject *vecA = NULL, *vecB = NULL; VectorObject *vecA = NULL, *vecB = NULL;
int result = 0; int result = 0;
@@ -1909,7 +1908,7 @@ static PySequenceMethods Vector_SeqMethods = {
(ssizeargfunc) NULL, /* sq_inplace_repeat */ (ssizeargfunc) NULL, /* sq_inplace_repeat */
}; };
static PyObject *Vector_subscript(VectorObject* self, PyObject* item) static PyObject *Vector_subscript(VectorObject *self, PyObject *item)
{ {
if (PyIndex_Check(item)) { if (PyIndex_Check(item)) {
Py_ssize_t i; Py_ssize_t i;
@@ -1946,7 +1945,7 @@ static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
} }
} }
static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* value) static int Vector_ass_subscript(VectorObject *self, PyObject *item, PyObject *value)
{ {
if (PyIndex_Check(item)) { if (PyIndex_Check(item)) {
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
@@ -2054,7 +2053,7 @@ static int Vector_length_set(VectorObject *self, PyObject *value)
if (BaseMath_ReadCallback(self) == -1) if (BaseMath_ReadCallback(self) == -1)
return -1; return -1;
if ((param=PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) { if ((param = PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
"length must be set to a number"); "length must be set to a number");
return -1; return -1;
@@ -2070,19 +2069,19 @@ static int Vector_length_set(VectorObject *self, PyObject *value)
return 0; return 0;
} }
dot= dot_vn_vn(self->vec, self->vec, self->size); dot = dot_vn_vn(self->vec, self->vec, self->size);
if (!dot) /* cant sqrt zero */ if (!dot) /* cant sqrt zero */
return 0; return 0;
dot = sqrt(dot); dot = sqrt(dot);
if (dot==param) if (dot == param)
return 0; return 0;
dot= dot/param; dot = dot / param;
mul_vn_fl(self->vec, self->size, 1.0/dot); mul_vn_fl(self->vec, self->size, 1.0 / dot);
(void)BaseMath_WriteCallback(self); /* checked already */ (void)BaseMath_WriteCallback(self); /* checked already */
@@ -2161,7 +2160,7 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure
/* Check that the closure can be used with this vector: even 2D vectors have /* Check that the closure can be used with this vector: even 2D vectors have
swizzles defined for axes z and w, but they would be invalid. */ swizzles defined for axes z and w, but they would be invalid. */
swizzleClosure = GET_INT_FROM_POINTER(closure); swizzleClosure = GET_INT_FROM_POINTER(closure);
axis_from= 0; axis_from = 0;
while (swizzleClosure & SWIZZLE_VALID_AXIS) { while (swizzleClosure & SWIZZLE_VALID_AXIS) {
axis_to = swizzleClosure & SWIZZLE_AXIS; axis_to = swizzleClosure & SWIZZLE_AXIS;
if (axis_to >= self->size) if (axis_to >= self->size)
@@ -2175,15 +2174,15 @@ static int Vector_swizzle_set(VectorObject *self, PyObject *value, void *closure
axis_from++; axis_from++;
} }
if (((scalarVal=PyFloat_AsDouble(value)) == -1 && PyErr_Occurred())==0) { if (((scalarVal = PyFloat_AsDouble(value)) == -1 && PyErr_Occurred()) == 0) {
int i; int i;
for (i=0; i < MAX_DIMENSIONS; i++) for (i = 0; i < MAX_DIMENSIONS; i++)
vec_assign[i]= scalarVal; vec_assign[i] = scalarVal;
size_from= axis_from; size_from = axis_from;
} }
else if ( (PyErr_Clear()), /* run but ignore the result */ else if ( (PyErr_Clear()), /* run but ignore the result */
(size_from=mathutils_array_parse(vec_assign, 2, 4, value, (size_from = mathutils_array_parse(vec_assign, 2, 4, value,
"mathutils.Vector.**** = swizzle assignment")) == -1) "mathutils.Vector.**** = swizzle assignment")) == -1)
{ {
return -1; return -1;
@@ -2619,7 +2618,7 @@ static int row_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject *v
{ {
float vec_cpy[MAX_DIMENSIONS]; float vec_cpy[MAX_DIMENSIONS];
double dot = 0.0f; double dot = 0.0f;
int row, col, z= 0, vec_size= vec->size; int row, col, z = 0, vec_size = vec->size;
if (mat->num_row != vec_size) { if (mat->num_row != vec_size) {
if (mat->num_row == 4 && vec_size == 3) { if (mat->num_row == 4 && vec_size == 3) {
@@ -2818,22 +2817,22 @@ PyObject *Vector_CreatePyObject(float *vec, const int size, const int type, PyTy
return NULL; return NULL;
} }
self= base_type ? (VectorObject *)base_type->tp_alloc(base_type, 0) : self = base_type ? (VectorObject *)base_type->tp_alloc(base_type, 0) :
(VectorObject *)PyObject_GC_New(VectorObject, &vector_Type); (VectorObject *)PyObject_GC_New(VectorObject, &vector_Type);
if (self) { if (self) {
self->size = size; self->size = size;
/* init callbacks as NULL */ /* init callbacks as NULL */
self->cb_user= NULL; self->cb_user = NULL;
self->cb_type= self->cb_subtype= 0; self->cb_type = self->cb_subtype = 0;
if (type == Py_WRAP) { if (type == Py_WRAP) {
self->vec = vec; self->vec = vec;
self->wrapped = Py_WRAP; self->wrapped = Py_WRAP;
} }
else if (type == Py_NEW) { else if (type == Py_NEW) {
self->vec= PyMem_Malloc(size * sizeof(float)); self->vec = PyMem_Malloc(size * sizeof(float));
if (vec) { if (vec) {
memcpy(self->vec, vec, size * sizeof(float)); memcpy(self->vec, vec, size * sizeof(float));
} }
@@ -2855,12 +2854,12 @@ PyObject *Vector_CreatePyObject(float *vec, const int size, const int type, PyTy
PyObject *Vector_CreatePyObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype) PyObject *Vector_CreatePyObject_cb(PyObject *cb_user, int size, int cb_type, int cb_subtype)
{ {
float dummy[4] = {0.0, 0.0, 0.0, 0.0}; /* dummy init vector, callbacks will be used on access */ float dummy[4] = {0.0, 0.0, 0.0, 0.0}; /* dummy init vector, callbacks will be used on access */
VectorObject *self= (VectorObject *)Vector_CreatePyObject(dummy, size, Py_NEW, NULL); VectorObject *self = (VectorObject *)Vector_CreatePyObject(dummy, size, Py_NEW, NULL);
if (self) { if (self) {
Py_INCREF(cb_user); Py_INCREF(cb_user);
self->cb_user= cb_user; self->cb_user = cb_user;
self->cb_type= (unsigned char)cb_type; self->cb_type = (unsigned char)cb_type;
self->cb_subtype= (unsigned char)cb_subtype; self->cb_subtype = (unsigned char)cb_subtype;
PyObject_GC_Track(self); PyObject_GC_Track(self);
} }
@@ -2870,8 +2869,8 @@ PyObject *Vector_CreatePyObject_cb(PyObject *cb_user, int size, int cb_type, int
PyObject *Vector_CreatePyObject_alloc(float *vec, const int size, PyTypeObject *base_type) PyObject *Vector_CreatePyObject_alloc(float *vec, const int size, PyTypeObject *base_type)
{ {
VectorObject *vect_ob; VectorObject *vect_ob;
vect_ob= (VectorObject *)Vector_CreatePyObject(vec, size, Py_WRAP, base_type); vect_ob = (VectorObject *)Vector_CreatePyObject(vec, size, Py_WRAP, base_type);
vect_ob->wrapped= Py_NEW; vect_ob->wrapped = Py_NEW;
return (PyObject *)vect_ob; return (PyObject *)vect_ob;
} }

260
source/blender/python/mathutils/mathutils_geometry.c
View File

@@ -47,7 +47,7 @@
#include "BLI_math.h" #include "BLI_math.h"
#include "BLI_utildefines.h" #include "BLI_utildefines.h"
#define SWAP_FLOAT(a, b, tmp) tmp=a; a=b; b=tmp #define SWAP_FLOAT(a, b, tmp) tmp = a; a = b; b = tmp
/*-------------------------DOC STRINGS ---------------------------*/ /*-------------------------DOC STRINGS ---------------------------*/
PyDoc_STRVAR(M_Geometry_doc, PyDoc_STRVAR(M_Geometry_doc,
@@ -76,12 +76,12 @@ PyDoc_STRVAR(M_Geometry_intersect_ray_tri_doc,
" :return: The point of intersection or None if no intersection is found\n" " :return: The point of intersection or None if no intersection is found\n"
" :rtype: :class:`mathutils.Vector` or None\n" " :rtype: :class:`mathutils.Vector` or None\n"
); );
static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *ray, *ray_off, *vec1, *vec2, *vec3; VectorObject *ray, *ray_off, *vec1, *vec2, *vec3;
float dir[3], orig[3], v1[3], v2[3], v3[3], e1[3], e2[3], pvec[3], tvec[3], qvec[3]; float dir[3], orig[3], v1[3], v2[3], v3[3], e1[3], e2[3], pvec[3], tvec[3], qvec[3];
float det, inv_det, u, v, t; float det, inv_det, u, v, t;
int clip= 1; int clip = 1;
if (!PyArg_ParseTuple(args, if (!PyArg_ParseTuple(args,
"O!O!O!O!O!|i:intersect_ray_tri", "O!O!O!O!O!|i:intersect_ray_tri",
@@ -125,19 +125,19 @@ static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject*
cross_v3_v3v3(pvec, dir, e2); cross_v3_v3v3(pvec, dir, e2);
/* if determinant is near zero, ray lies in plane of triangle */ /* if determinant is near zero, ray lies in plane of triangle */
det= dot_v3v3(e1, pvec); det = dot_v3v3(e1, pvec);
if (det > -0.000001f && det < 0.000001f) { if (det > -0.000001f && det < 0.000001f) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
inv_det= 1.0f / det; inv_det = 1.0f / det;
/* calculate distance from v1 to ray origin */ /* calculate distance from v1 to ray origin */
sub_v3_v3v3(tvec, orig, v1); sub_v3_v3v3(tvec, orig, v1);
/* calculate U parameter and test bounds */ /* calculate U parameter and test bounds */
u= dot_v3v3(tvec, pvec) * inv_det; u = dot_v3v3(tvec, pvec) * inv_det;
if (clip && (u < 0.0f || u > 1.0f)) { if (clip && (u < 0.0f || u > 1.0f)) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
@@ -146,14 +146,14 @@ static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject*
cross_v3_v3v3(qvec, tvec, e1); cross_v3_v3v3(qvec, tvec, e1);
/* calculate V parameter and test bounds */ /* calculate V parameter and test bounds */
v= dot_v3v3(dir, qvec) * inv_det; v = dot_v3v3(dir, qvec) * inv_det;
if (clip && (v < 0.0f || u + v > 1.0f)) { if (clip && (v < 0.0f || u + v > 1.0f)) {
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* calculate t, ray intersects triangle */ /* calculate t, ray intersects triangle */
t= dot_v3v3(e2, qvec) * inv_det; t = dot_v3v3(e2, qvec) * inv_det;
mul_v3_fl(dir, t); mul_v3_fl(dir, t);
add_v3_v3v3(pvec, orig, dir); add_v3_v3v3(pvec, orig, dir);
@@ -217,31 +217,31 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
copy_v3_v3(v4, vec4->vec); copy_v3_v3(v4, vec4->vec);
} }
else { else {
v1[0]= vec1->vec[0]; v1[0] = vec1->vec[0];
v1[1]= vec1->vec[1]; v1[1] = vec1->vec[1];
v1[2]= 0.0f; v1[2] = 0.0f;
v2[0]= vec2->vec[0]; v2[0] = vec2->vec[0];
v2[1]= vec2->vec[1]; v2[1] = vec2->vec[1];
v2[2]= 0.0f; v2[2] = 0.0f;
v3[0]= vec3->vec[0]; v3[0] = vec3->vec[0];
v3[1]= vec3->vec[1]; v3[1] = vec3->vec[1];
v3[2]= 0.0f; v3[2] = 0.0f;
v4[0]= vec4->vec[0]; v4[0] = vec4->vec[0];
v4[1]= vec4->vec[1]; v4[1] = vec4->vec[1];
v4[2]= 0.0f; v4[2] = 0.0f;
} }
result= isect_line_line_v3(v1, v2, v3, v4, i1, i2); result = isect_line_line_v3(v1, v2, v3, v4, i1, i2);
if (result == 0) { if (result == 0) {
/* colinear */ /* colinear */
Py_RETURN_NONE; Py_RETURN_NONE;
} }
else { else {
tuple= PyTuple_New(2); tuple = PyTuple_New(2);
PyTuple_SET_ITEM(tuple, 0, Vector_CreatePyObject(i1, vec1->size, Py_NEW, NULL)); PyTuple_SET_ITEM(tuple, 0, Vector_CreatePyObject(i1, vec1->size, Py_NEW, NULL));
PyTuple_SET_ITEM(tuple, 1, Vector_CreatePyObject(i2, vec1->size, Py_NEW, NULL)); PyTuple_SET_ITEM(tuple, 1, Vector_CreatePyObject(i2, vec1->size, Py_NEW, NULL));
return tuple; return tuple;
@@ -273,7 +273,7 @@ PyDoc_STRVAR(M_Geometry_normal_doc,
" :type v4: :class:`mathutils.Vector`\n" " :type v4: :class:`mathutils.Vector`\n"
" :rtype: :class:`mathutils.Vector`\n" " :rtype: :class:`mathutils.Vector`\n"
); );
static PyObject *M_Geometry_normal(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_normal(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *vec1, *vec2, *vec3, *vec4; VectorObject *vec1, *vec2, *vec3, *vec4;
float n[3]; float n[3];
@@ -356,7 +356,7 @@ PyDoc_STRVAR(M_Geometry_area_tri_doc,
" :type v3: :class:`mathutils.Vector`\n" " :type v3: :class:`mathutils.Vector`\n"
" :rtype: float\n" " :rtype: float\n"
); );
static PyObject *M_Geometry_area_tri(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_area_tri(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *vec1, *vec2, *vec3; VectorObject *vec1, *vec2, *vec3;
@@ -411,7 +411,7 @@ PyDoc_STRVAR(M_Geometry_intersect_line_line_2d_doc,
" :return: The point of intersection or None when not found\n" " :return: The point of intersection or None when not found\n"
" :rtype: :class:`mathutils.Vector` or None\n" " :rtype: :class:`mathutils.Vector` or None\n"
); );
static PyObject *M_Geometry_intersect_line_line_2d(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_line_line_2d(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *line_a1, *line_a2, *line_b1, *line_b2; VectorObject *line_a1, *line_a2, *line_b1, *line_b2;
float vi[2]; float vi[2];
@@ -459,10 +459,10 @@ PyDoc_STRVAR(M_Geometry_intersect_line_plane_doc,
" :return: The point of intersection or None when not found\n" " :return: The point of intersection or None when not found\n"
" :rtype: :class:`mathutils.Vector` or None\n" " :rtype: :class:`mathutils.Vector` or None\n"
); );
static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *line_a, *line_b, *plane_co, *plane_no; VectorObject *line_a, *line_b, *plane_co, *plane_no;
int no_flip= 0; int no_flip = 0;
float isect[3]; float isect[3];
if (!PyArg_ParseTuple(args, "O!O!O!O!|i:intersect_line_plane", if (!PyArg_ParseTuple(args, "O!O!O!O!|i:intersect_line_plane",
&vector_Type, &line_a, &vector_Type, &line_a,
@@ -513,7 +513,7 @@ PyDoc_STRVAR(M_Geometry_intersect_plane_plane_doc,
" :return: The line of the intersection represented as a point and a vector\n" " :return: The line of the intersection represented as a point and a vector\n"
" :rtype: tuple pair of :class:`mathutils.Vector`\n" " :rtype: tuple pair of :class:`mathutils.Vector`\n"
); );
static PyObject *M_Geometry_intersect_plane_plane(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_plane_plane(PyObject *UNUSED(self), PyObject *args)
{ {
PyObject *ret; PyObject *ret;
VectorObject *plane_a_co, *plane_a_no, *plane_b_co, *plane_b_no; VectorObject *plane_a_co, *plane_a_no, *plane_b_co, *plane_b_no;
@@ -551,7 +551,7 @@ static PyObject *M_Geometry_intersect_plane_plane(PyObject *UNUSED(self), PyObje
normalize_v3(isect_no); normalize_v3(isect_no);
ret= PyTuple_New(2); ret = PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(isect_co, 3, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(isect_co, 3, Py_NEW, NULL));
PyTuple_SET_ITEM(ret, 1, Vector_CreatePyObject(isect_no, 3, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 1, Vector_CreatePyObject(isect_no, 3, Py_NEW, NULL));
return ret; return ret;
@@ -574,11 +574,11 @@ PyDoc_STRVAR(M_Geometry_intersect_line_sphere_doc,
" :return: The intersection points as a pair of vectors or None when there is no intersection\n" " :return: The intersection points as a pair of vectors or None when there is no intersection\n"
" :rtype: A tuple pair containing :class:`mathutils.Vector` or None\n" " :rtype: A tuple pair containing :class:`mathutils.Vector` or None\n"
); );
static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *line_a, *line_b, *sphere_co; VectorObject *line_a, *line_b, *sphere_co;
float sphere_radius; float sphere_radius;
int clip= TRUE; int clip = TRUE;
float isect_a[3]; float isect_a[3];
float isect_b[3]; float isect_b[3];
@@ -606,24 +606,24 @@ static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObje
return NULL; return NULL;
} }
else { else {
short use_a= TRUE; short use_a = TRUE;
short use_b= TRUE; short use_b = TRUE;
float lambda; float lambda;
PyObject *ret= PyTuple_New(2); PyObject *ret = PyTuple_New(2);
switch (isect_line_sphere_v3(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) { switch (isect_line_sphere_v3(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) {
case 1: case 1:
if (!(!clip || (((lambda= line_point_factor_v3(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE; if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a = FALSE;
use_b= FALSE; use_b = FALSE;
break; break;
case 2: case 2:
if (!(!clip || (((lambda= line_point_factor_v3(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE; if (!(!clip || (((lambda = line_point_factor_v3(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a = FALSE;
if (!(!clip || (((lambda= line_point_factor_v3(isect_b, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_b= FALSE; if (!(!clip || (((lambda = line_point_factor_v3(isect_b, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_b = FALSE;
break; break;
default: default:
use_a= FALSE; use_a = FALSE;
use_b= FALSE; use_b = FALSE;
} }
if (use_a) { PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(isect_a, 3, Py_NEW, NULL)); } if (use_a) { PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(isect_a, 3, Py_NEW, NULL)); }
@@ -654,11 +654,11 @@ PyDoc_STRVAR(M_Geometry_intersect_line_sphere_2d_doc,
" :return: The intersection points as a pair of vectors or None when there is no intersection\n" " :return: The intersection points as a pair of vectors or None when there is no intersection\n"
" :rtype: A tuple pair containing :class:`mathutils.Vector` or None\n" " :rtype: A tuple pair containing :class:`mathutils.Vector` or None\n"
); );
static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *line_a, *line_b, *sphere_co; VectorObject *line_a, *line_b, *sphere_co;
float sphere_radius; float sphere_radius;
int clip= TRUE; int clip = TRUE;
float isect_a[3]; float isect_a[3];
float isect_b[3]; float isect_b[3];
@@ -679,24 +679,24 @@ static PyObject *M_Geometry_intersect_line_sphere_2d(PyObject *UNUSED(self), PyO
return NULL; return NULL;
} }
else { else {
short use_a= TRUE; short use_a = TRUE;
short use_b= TRUE; short use_b = TRUE;
float lambda; float lambda;
PyObject *ret= PyTuple_New(2); PyObject *ret = PyTuple_New(2);
switch (isect_line_sphere_v2(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) { switch (isect_line_sphere_v2(line_a->vec, line_b->vec, sphere_co->vec, sphere_radius, isect_a, isect_b)) {
case 1: case 1:
if (!(!clip || (((lambda= line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE; if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a = FALSE;
use_b= FALSE; use_b = FALSE;
break; break;
case 2: case 2:
if (!(!clip || (((lambda= line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a= FALSE; if (!(!clip || (((lambda = line_point_factor_v2(isect_a, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_a = FALSE;
if (!(!clip || (((lambda= line_point_factor_v2(isect_b, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_b= FALSE; if (!(!clip || (((lambda = line_point_factor_v2(isect_b, line_a->vec, line_b->vec)) >= 0.0f) && (lambda <= 1.0f)))) use_b = FALSE;
break; break;
default: default:
use_a= FALSE; use_a = FALSE;
use_b= FALSE; use_b = FALSE;
} }
if (use_a) { PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(isect_a, 2, Py_NEW, NULL)); } if (use_a) { PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(isect_a, 2, Py_NEW, NULL)); }
@@ -722,7 +722,7 @@ PyDoc_STRVAR(M_Geometry_intersect_point_line_doc,
" :type line_p1: :class:`mathutils.Vector`\n" " :type line_p1: :class:`mathutils.Vector`\n"
" :rtype: (:class:`mathutils.Vector`, float)\n" " :rtype: (:class:`mathutils.Vector`, float)\n"
); );
static PyObject *M_Geometry_intersect_point_line(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_point_line(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *pt, *line_1, *line_2; VectorObject *pt, *line_1, *line_2;
float pt_in[3], pt_out[3], l1[3], l2[3]; float pt_in[3], pt_out[3], l1[3], l2[3];
@@ -745,19 +745,19 @@ static PyObject *M_Geometry_intersect_point_line(PyObject *UNUSED(self), PyObjec
} }
/* accept 2d verts */ /* accept 2d verts */
if (pt->size==3) { copy_v3_v3(pt_in, pt->vec);} if (pt->size == 3) { copy_v3_v3(pt_in, pt->vec);}
else { pt_in[2]=0.0; copy_v2_v2(pt_in, pt->vec); } else { pt_in[2] = 0.0f; copy_v2_v2(pt_in, pt->vec); }
if (line_1->size==3) { copy_v3_v3(l1, line_1->vec);} if (line_1->size == 3) { copy_v3_v3(l1, line_1->vec);}
else { l1[2]=0.0; copy_v2_v2(l1, line_1->vec); } else { l1[2] = 0.0f; copy_v2_v2(l1, line_1->vec); }
if (line_2->size==3) { copy_v3_v3(l2, line_2->vec);} if (line_2->size == 3) { copy_v3_v3(l2, line_2->vec);}
else { l2[2]=0.0; copy_v2_v2(l2, line_2->vec); } else { l2[2] = 0.0f; copy_v2_v2(l2, line_2->vec); }
/* do the calculation */ /* do the calculation */
lambda= closest_to_line_v3(pt_out, pt_in, l1, l2); lambda = closest_to_line_v3(pt_out, pt_in, l1, l2);
ret= PyTuple_New(2); ret = PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(pt_out, 3, Py_NEW, NULL)); PyTuple_SET_ITEM(ret, 0, Vector_CreatePyObject(pt_out, 3, Py_NEW, NULL));
PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(lambda)); PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(lambda));
return ret; return ret;
@@ -778,7 +778,7 @@ PyDoc_STRVAR(M_Geometry_intersect_point_tri_2d_doc,
" :type tri_p3: :class:`mathutils.Vector`\n" " :type tri_p3: :class:`mathutils.Vector`\n"
" :rtype: int\n" " :rtype: int\n"
); );
static PyObject *M_Geometry_intersect_point_tri_2d(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_point_tri_2d(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *pt_vec, *tri_p1, *tri_p2, *tri_p3; VectorObject *pt_vec, *tri_p1, *tri_p2, *tri_p3;
@@ -820,7 +820,7 @@ PyDoc_STRVAR(M_Geometry_intersect_point_quad_2d_doc,
" :type quad_p4: :class:`mathutils.Vector`\n" " :type quad_p4: :class:`mathutils.Vector`\n"
" :rtype: int\n" " :rtype: int\n"
); );
static PyObject *M_Geometry_intersect_point_quad_2d(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_intersect_point_quad_2d(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *pt_vec, *quad_p1, *quad_p2, *quad_p3, *quad_p4; VectorObject *pt_vec, *quad_p1, *quad_p2, *quad_p3, *quad_p4;
@@ -860,7 +860,7 @@ PyDoc_STRVAR(M_Geometry_distance_point_to_plane_doc,
" :type plane_no: :class:`mathutils.Vector`\n" " :type plane_no: :class:`mathutils.Vector`\n"
" :rtype: float\n" " :rtype: float\n"
); );
static PyObject *M_Geometry_distance_point_to_plane(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_distance_point_to_plane(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *pt, *plene_co, *plane_no; VectorObject *pt, *plene_co, *plane_no;
@@ -963,7 +963,7 @@ PyDoc_STRVAR(M_Geometry_interpolate_bezier_doc,
" :return: The interpolated points\n" " :return: The interpolated points\n"
" :rtype: list of :class:`mathutils.Vector`'s\n" " :rtype: list of :class:`mathutils.Vector`'s\n"
); );
static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject* args) static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject *args)
{ {
VectorObject *vec_k1, *vec_h1, *vec_k2, *vec_h2; VectorObject *vec_k1, *vec_h1, *vec_k2, *vec_h2;
int resolu; int resolu;
@@ -972,10 +972,10 @@ static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject*
float *coord_array, *fp; float *coord_array, *fp;
PyObject *list; PyObject *list;
float k1[4]= {0.0, 0.0, 0.0, 0.0}; float k1[4] = {0.0, 0.0, 0.0, 0.0};
float h1[4]= {0.0, 0.0, 0.0, 0.0}; float h1[4] = {0.0, 0.0, 0.0, 0.0};
float k2[4]= {0.0, 0.0, 0.0, 0.0}; float k2[4] = {0.0, 0.0, 0.0, 0.0};
float h2[4]= {0.0, 0.0, 0.0, 0.0}; float h2[4] = {0.0, 0.0, 0.0, 0.0};
if (!PyArg_ParseTuple(args, "O!O!O!O!i:interpolate_bezier", if (!PyArg_ParseTuple(args, "O!O!O!O!i:interpolate_bezier",
@@ -1001,21 +1001,21 @@ static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject*
return NULL; return NULL;
} }
dims= MAX4(vec_k1->size, vec_h1->size, vec_h2->size, vec_k2->size); dims = MAX4(vec_k1->size, vec_h1->size, vec_h2->size, vec_k2->size);
for (i=0; i < vec_k1->size; i++) k1[i]= vec_k1->vec[i]; for (i = 0; i < vec_k1->size; i++) k1[i] = vec_k1->vec[i];
for (i=0; i < vec_h1->size; i++) h1[i]= vec_h1->vec[i]; for (i = 0; i < vec_h1->size; i++) h1[i] = vec_h1->vec[i];
for (i=0; i < vec_k2->size; i++) k2[i]= vec_k2->vec[i]; for (i = 0; i < vec_k2->size; i++) k2[i] = vec_k2->vec[i];
for (i=0; i < vec_h2->size; i++) h2[i]= vec_h2->vec[i]; for (i = 0; i < vec_h2->size; i++) h2[i] = vec_h2->vec[i];
coord_array= MEM_callocN(dims * (resolu) * sizeof(float), "interpolate_bezier"); coord_array = MEM_callocN(dims * (resolu) * sizeof(float), "interpolate_bezier");
for (i=0; i<dims; i++) { for (i = 0; i < dims; i++) {
forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array+i, resolu-1, sizeof(float)*dims); forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array + i, resolu - 1, sizeof(float)*dims);
} }
list= PyList_New(resolu); list = PyList_New(resolu);
fp= coord_array; fp = coord_array;
for (i=0; i<resolu; i++, fp= fp+dims) { for (i = 0; i < resolu; i++, fp = fp + dims) {
PyList_SET_ITEM(list, i, Vector_CreatePyObject(fp, dims, Py_NEW, NULL)); PyList_SET_ITEM(list, i, Vector_CreatePyObject(fp, dims, Py_NEW, NULL));
} }
MEM_freeN(coord_array); MEM_freeN(coord_array);
@@ -1036,13 +1036,13 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
{ {
PyObject *tri_list; /*return this list of tri's */ PyObject *tri_list; /*return this list of tri's */
PyObject *polyLine, *polyVec; PyObject *polyLine, *polyVec;
int i, len_polylines, len_polypoints, ls_error= 0; int i, len_polylines, len_polypoints, ls_error = 0;
/* display listbase */ /* display listbase */
ListBase dispbase={NULL, NULL}; ListBase dispbase = {NULL, NULL};
DispList *dl; DispList *dl;
float *fp; /*pointer to the array of malloced dl->verts to set the points from the vectors */ float *fp; /*pointer to the array of malloced dl->verts to set the points from the vectors */
int index, *dl_face, totpoints=0; int index, *dl_face, totpoints = 0;
if (!PySequence_Check(polyLineSeq)) { if (!PySequence_Check(polyLineSeq)) {
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
@@ -1050,10 +1050,10 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
return NULL; return NULL;
} }
len_polylines= PySequence_Size(polyLineSeq); len_polylines = PySequence_Size(polyLineSeq);
for (i= 0; i < len_polylines; ++i) { for (i = 0; i < len_polylines; ++i) {
polyLine= PySequence_GetItem(polyLineSeq, i); polyLine = PySequence_GetItem(polyLineSeq, i);
if (!PySequence_Check(polyLine)) { if (!PySequence_Check(polyLine)) {
freedisplist(&dispbase); freedisplist(&dispbase);
Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/ Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/
@@ -1062,8 +1062,8 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
return NULL; return NULL;
} }
len_polypoints= PySequence_Size(polyLine); len_polypoints = PySequence_Size(polyLine);
if (len_polypoints>0) { /* dont bother adding edges as polylines */ if (len_polypoints > 0) { /* dont bother adding edges as polylines */
#if 0 #if 0
if (EXPP_check_sequence_consistency(polyLine, &vector_Type) != 1) { if (EXPP_check_sequence_consistency(polyLine, &vector_Type) != 1) {
freedisplist(&dispbase); freedisplist(&dispbase);
@@ -1073,32 +1073,32 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
return NULL; return NULL;
} }
#endif #endif
dl= MEM_callocN(sizeof(DispList), "poly disp"); dl = MEM_callocN(sizeof(DispList), "poly disp");
BLI_addtail(&dispbase, dl); BLI_addtail(&dispbase, dl);
dl->type= DL_INDEX3; dl->type = DL_INDEX3;
dl->nr= len_polypoints; dl->nr = len_polypoints;
dl->type= DL_POLY; dl->type = DL_POLY;
dl->parts= 1; /* no faces, 1 edge loop */ dl->parts = 1; /* no faces, 1 edge loop */
dl->col= 0; /* no material */ dl->col = 0; /* no material */
dl->verts= fp= MEM_callocN(sizeof(float)*3*len_polypoints, "dl verts"); dl->verts = fp = MEM_callocN(sizeof(float) * 3 * len_polypoints, "dl verts");
dl->index= MEM_callocN(sizeof(int)*3*len_polypoints, "dl index"); dl->index = MEM_callocN(sizeof(int) * 3 * len_polypoints, "dl index");
for (index= 0; index<len_polypoints; ++index, fp+=3) { for (index = 0; index < len_polypoints; ++index, fp += 3) {
polyVec= PySequence_GetItem(polyLine, index); polyVec = PySequence_GetItem(polyLine, index);
if (VectorObject_Check(polyVec)) { if (VectorObject_Check(polyVec)) {
if (BaseMath_ReadCallback((VectorObject *)polyVec) == -1) if (BaseMath_ReadCallback((VectorObject *)polyVec) == -1)
ls_error= 1; ls_error = 1;
fp[0]= ((VectorObject *)polyVec)->vec[0]; fp[0] = ((VectorObject *)polyVec)->vec[0];
fp[1]= ((VectorObject *)polyVec)->vec[1]; fp[1] = ((VectorObject *)polyVec)->vec[1];
if (((VectorObject *)polyVec)->size > 2) if (((VectorObject *)polyVec)->size > 2)
fp[2]= ((VectorObject *)polyVec)->vec[2]; fp[2] = ((VectorObject *)polyVec)->vec[2];
else else
fp[2]= 0.0f; /* if its a 2d vector then set the z to be zero */ fp[2] = 0.0f; /* if its a 2d vector then set the z to be zero */
} }
else { else {
ls_error= 1; ls_error = 1;
} }
totpoints++; totpoints++;
@@ -1121,9 +1121,9 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
/* The faces are stored in a new DisplayList /* The faces are stored in a new DisplayList
thats added to the head of the listbase */ thats added to the head of the listbase */
dl= dispbase.first; dl = dispbase.first;
tri_list= PyList_New(dl->parts); tri_list = PyList_New(dl->parts);
if (!tri_list) { if (!tri_list) {
freedisplist(&dispbase); freedisplist(&dispbase);
PyErr_SetString(PyExc_RuntimeError, PyErr_SetString(PyExc_RuntimeError,
@@ -1131,11 +1131,11 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
return NULL; return NULL;
} }
index= 0; index = 0;
dl_face= dl->index; dl_face = dl->index;
while (index < dl->parts) { while (index < dl->parts) {
PyList_SET_ITEM(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2])); PyList_SET_ITEM(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2]));
dl_face+= 3; dl_face += 3;
index++; index++;
} }
freedisplist(&dispbase); freedisplist(&dispbase);
@@ -1143,7 +1143,7 @@ static PyObject *M_Geometry_tesselate_polygon(PyObject *UNUSED(self), PyObject *
else { else {
/* no points, do this so scripts dont barf */ /* no points, do this so scripts dont barf */
freedisplist(&dispbase); /* possible some dl was allocated */ freedisplist(&dispbase); /* possible some dl was allocated */
tri_list= PyList_New(0); tri_list = PyList_New(0);
} }
return tri_list; return tri_list;
@@ -1164,13 +1164,13 @@ static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray)
return -1; return -1;
} }
len= PyList_GET_SIZE(value); len = PyList_GET_SIZE(value);
(*boxarray)= MEM_mallocN(len*sizeof(boxPack), "boxPack box"); *boxarray = MEM_mallocN(len * sizeof(boxPack), "boxPack box");
for (i= 0; i < len; i++) { for (i = 0; i < len; i++) {
list_item= PyList_GET_ITEM(value, i); list_item = PyList_GET_ITEM(value, i);
if (!PyList_Check(list_item) || PyList_GET_SIZE(list_item) < 4) { if (!PyList_Check(list_item) || PyList_GET_SIZE(list_item) < 4) {
MEM_freeN(*boxarray); MEM_freeN(*boxarray);
PyErr_SetString(PyExc_TypeError, PyErr_SetString(PyExc_TypeError,
@@ -1178,14 +1178,14 @@ static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray)
return -1; return -1;
} }
box= (*boxarray)+i; box = (*boxarray) + i;
item_1= PyList_GET_ITEM(list_item, 2); item_1 = PyList_GET_ITEM(list_item, 2);
item_2= PyList_GET_ITEM(list_item, 3); item_2 = PyList_GET_ITEM(list_item, 3);
box->w= (float)PyFloat_AsDouble(item_1); box->w = (float)PyFloat_AsDouble(item_1);
box->h= (float)PyFloat_AsDouble(item_2); box->h = (float)PyFloat_AsDouble(item_2);
box->index= i; box->index = i;
/* accounts for error case too and overwrites with own error */ /* accounts for error case too and overwrites with own error */
if (box->w < 0.0f || box->h < 0.0f) { if (box->w < 0.0f || box->h < 0.0f) {
@@ -1207,11 +1207,11 @@ static void boxPack_ToPyObject(PyObject *value, boxPack **boxarray)
PyObject *list_item; PyObject *list_item;
boxPack *box; boxPack *box;
len= PyList_GET_SIZE(value); len = PyList_GET_SIZE(value);
for (i= 0; i < len; i++) { for (i = 0; i < len; i++) {
box= (*boxarray)+i; box = (*boxarray)+i;
list_item= PyList_GET_ITEM(value, box->index); list_item = PyList_GET_ITEM(value, box->index);
PyList_SET_ITEM(list_item, 0, PyFloat_FromDouble(box->x)); PyList_SET_ITEM(list_item, 0, PyFloat_FromDouble(box->x));
PyList_SET_ITEM(list_item, 1, PyFloat_FromDouble(box->y)); PyList_SET_ITEM(list_item, 1, PyFloat_FromDouble(box->y));
} }
@@ -1230,7 +1230,7 @@ PyDoc_STRVAR(M_Geometry_box_pack_2d_doc,
); );
static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlist) static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlist)
{ {
float tot_width= 0.0f, tot_height= 0.0f; float tot_width = 0.0f, tot_height = 0.0f;
Py_ssize_t len; Py_ssize_t len;
PyObject *ret; PyObject *ret;
@@ -1241,9 +1241,9 @@ static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlis
return NULL; return NULL;
} }
len= PyList_GET_SIZE(boxlist); len = PyList_GET_SIZE(boxlist);
if (len) { if (len) {
boxPack *boxarray= NULL; boxPack *boxarray = NULL;
if (boxPack_FromPyObject(boxlist, &boxarray) == -1) { if (boxPack_FromPyObject(boxlist, &boxarray) == -1) {
return NULL; /* exception set */ return NULL; /* exception set */
} }
@@ -1254,7 +1254,7 @@ static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlis
boxPack_ToPyObject(boxlist, &boxarray); boxPack_ToPyObject(boxlist, &boxarray);
} }
ret= PyTuple_New(2); ret = PyTuple_New(2);
PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(tot_width)); PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(tot_width));
PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(tot_width)); PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(tot_width));
return ret; return ret;
@@ -1263,7 +1263,7 @@ static PyObject *M_Geometry_box_pack_2d(PyObject *UNUSED(self), PyObject *boxlis
#endif /* MATH_STANDALONE */ #endif /* MATH_STANDALONE */
static PyMethodDef M_Geometry_methods[]= { static PyMethodDef M_Geometry_methods[] = {
{"intersect_ray_tri", (PyCFunction) M_Geometry_intersect_ray_tri, METH_VARARGS, M_Geometry_intersect_ray_tri_doc}, {"intersect_ray_tri", (PyCFunction) M_Geometry_intersect_ray_tri, METH_VARARGS, M_Geometry_intersect_ray_tri_doc},
{"intersect_point_line", (PyCFunction) M_Geometry_intersect_point_line, METH_VARARGS, M_Geometry_intersect_point_line_doc}, {"intersect_point_line", (PyCFunction) M_Geometry_intersect_point_line, METH_VARARGS, M_Geometry_intersect_point_line_doc},
{"intersect_point_tri_2d", (PyCFunction) M_Geometry_intersect_point_tri_2d, METH_VARARGS, M_Geometry_intersect_point_tri_2d_doc}, {"intersect_point_tri_2d", (PyCFunction) M_Geometry_intersect_point_tri_2d, METH_VARARGS, M_Geometry_intersect_point_tri_2d_doc},
@@ -1286,7 +1286,7 @@ static PyMethodDef M_Geometry_methods[]= {
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
static struct PyModuleDef M_Geometry_module_def= { static struct PyModuleDef M_Geometry_module_def = {
PyModuleDef_HEAD_INIT, PyModuleDef_HEAD_INIT,
"mathutils.geometry", /* m_name */ "mathutils.geometry", /* m_name */
M_Geometry_doc, /* m_doc */ M_Geometry_doc, /* m_doc */
@@ -1301,6 +1301,6 @@ static struct PyModuleDef M_Geometry_module_def= {
/*----------------------------MODULE INIT-------------------------*/ /*----------------------------MODULE INIT-------------------------*/
PyMODINIT_FUNC PyInit_mathutils_geometry(void) PyMODINIT_FUNC PyInit_mathutils_geometry(void)
{ {
PyObject *submodule= PyModule_Create(&M_Geometry_module_def); PyObject *submodule = PyModule_Create(&M_Geometry_module_def);
return submodule; return submodule;
} }

58
source/blender/python/mathutils/mathutils_noise.c
View File

@@ -199,8 +199,8 @@ static float frand(void)
/* Fills an array of length size with random numbers in the range (-1, 1)*/ /* Fills an array of length size with random numbers in the range (-1, 1)*/
static void rand_vn(float *array_tar, const int size) static void rand_vn(float *array_tar, const int size)
{ {
float *array_pt= array_tar + (size-1); float *array_pt = array_tar + (size-1);
int i= size; int i = size;
while (i--) { *(array_pt--) = 2.0f * frand() - 1.0f; } while (i--) { *(array_pt--) = 2.0f * frand() - 1.0f; }
} }
@@ -208,9 +208,9 @@ static void rand_vn(float *array_tar, const int size)
static void noise_vector(float x, float y, float z, int nb, float v[3]) static void noise_vector(float x, float y, float z, int nb, float v[3])
{ {
/* Simply evaluate noise at 3 different positions */ /* Simply evaluate noise at 3 different positions */
v[0]= (float)(2.0f * BLI_gNoise(1.f, x + 9.321f, y - 1.531f, z - 7.951f, 0, nb) - 1.0f); v[0] = (float)(2.0f * BLI_gNoise(1.f, x + 9.321f, y - 1.531f, z - 7.951f, 0, nb) - 1.0f);
v[1]= (float)(2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f); v[1] = (float)(2.0f * BLI_gNoise(1.f, x, y, z, 0, nb) - 1.0f);
v[2]= (float)(2.0f * BLI_gNoise(1.f, x + 6.327f, y + 0.1671f, z - 2.672f, 0, nb) - 1.0f); v[2] = (float)(2.0f * BLI_gNoise(1.f, x + 6.327f, y + 0.1671f, z - 2.672f, 0, nb) - 1.0f);
} }
/* Returns a turbulence value for a given position (x, y, z) */ /* Returns a turbulence value for a given position (x, y, z) */
@@ -301,9 +301,9 @@ PyDoc_STRVAR(M_Noise_random_unit_vector_doc,
); );
static PyObject *M_Noise_random_unit_vector(PyObject *UNUSED(self), PyObject *args) static PyObject *M_Noise_random_unit_vector(PyObject *UNUSED(self), PyObject *args)
{ {
float vec[4]= {0.0f, 0.0f, 0.0f, 0.0f}; float vec[4] = {0.0f, 0.0f, 0.0f, 0.0f};
float norm= 2.0f; float norm = 2.0f;
int size= 3; int size = 3;
if (!PyArg_ParseTuple(args, "|i:random_vector", &size)) if (!PyArg_ParseTuple(args, "|i:random_vector", &size))
return NULL; return NULL;
@@ -313,9 +313,9 @@ static PyObject *M_Noise_random_unit_vector(PyObject *UNUSED(self), PyObject *ar
return NULL; return NULL;
} }
while (norm==0.0f || norm>=1.0f) { while (norm == 0.0f || norm >= 1.0f) {
rand_vn(vec, size); rand_vn(vec, size);
norm= normalize_vn(vec, size); norm = normalize_vn(vec, size);
} }
return Vector_CreatePyObject(vec, size, Py_NEW, NULL); return Vector_CreatePyObject(vec, size, Py_NEW, NULL);
@@ -384,7 +384,7 @@ static PyObject *M_Noise_noise(PyObject *UNUSED(self), PyObject *args)
{ {
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "O|i:noise", &value, &nb)) if (!PyArg_ParseTuple(args, "O|i:noise", &value, &nb))
return NULL; return NULL;
@@ -410,7 +410,7 @@ static PyObject *M_Noise_noise_vector(PyObject *UNUSED(self), PyObject *args)
{ {
PyObject *value; PyObject *value;
float vec[3], r_vec[3]; float vec[3], r_vec[3];
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "O|i:noise_vector", &value, &nb)) if (!PyArg_ParseTuple(args, "O|i:noise_vector", &value, &nb))
return NULL; return NULL;
@@ -447,8 +447,8 @@ static PyObject *M_Noise_turbulence(PyObject *UNUSED(self), PyObject *args)
{ {
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
int oct, hd, nb= 1; int oct, hd, nb = 1;
float as= 0.5f, fs= 2.0f; float as = 0.5f, fs = 2.0f;
if (!PyArg_ParseTuple(args, "Oii|iff:turbulence", &value, &oct, &hd, &nb, &as, &fs)) if (!PyArg_ParseTuple(args, "Oii|iff:turbulence", &value, &oct, &hd, &nb, &as, &fs))
return NULL; return NULL;
@@ -483,8 +483,8 @@ static PyObject *M_Noise_turbulence_vector(PyObject *UNUSED(self), PyObject *arg
{ {
PyObject *value; PyObject *value;
float vec[3], r_vec[3]; float vec[3], r_vec[3];
int oct, hd, nb= 1; int oct, hd, nb = 1;
float as =0.5f, fs= 2.0f; float as =0.5f, fs = 2.0f;
if (!PyArg_ParseTuple(args, "Oii|iff:turbulence_vector", &value, &oct, &hd, &nb, &as, &fs)) if (!PyArg_ParseTuple(args, "Oii|iff:turbulence_vector", &value, &oct, &hd, &nb, &as, &fs))
return NULL; return NULL;
@@ -519,7 +519,7 @@ static PyObject *M_Noise_fractal(PyObject *UNUSED(self), PyObject *args)
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
float H, lac, oct; float H, lac, oct;
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "Offf|i:fractal", &value, &H, &lac, &oct, &nb)) if (!PyArg_ParseTuple(args, "Offf|i:fractal", &value, &H, &lac, &oct, &nb))
return NULL; return NULL;
@@ -553,7 +553,7 @@ static PyObject *M_Noise_multi_fractal(PyObject *UNUSED(self), PyObject *args)
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
float H, lac, oct; float H, lac, oct;
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "Offf|i:multi_fractal", &value, &H, &lac, &oct, &nb)) if (!PyArg_ParseTuple(args, "Offf|i:multi_fractal", &value, &H, &lac, &oct, &nb))
return NULL; return NULL;
@@ -585,7 +585,7 @@ static PyObject *M_Noise_variable_lacunarity(PyObject *UNUSED(self), PyObject *a
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
float d; float d;
int nt1= 1, nt2= 1; int nt1 = 1, nt2 = 1;
if (!PyArg_ParseTuple(args, "Of|ii:variable_lacunarity", &value, &d, &nt1, &nt2)) if (!PyArg_ParseTuple(args, "Of|ii:variable_lacunarity", &value, &d, &nt1, &nt2))
return NULL; return NULL;
@@ -621,7 +621,7 @@ static PyObject *M_Noise_hetero_terrain(PyObject *UNUSED(self), PyObject *args)
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
float H, lac, oct, ofs; float H, lac, oct, ofs;
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "Offff|i:hetero_terrain", &value, &H, &lac, &oct, &ofs, &nb)) if (!PyArg_ParseTuple(args, "Offff|i:hetero_terrain", &value, &H, &lac, &oct, &ofs, &nb))
return NULL; return NULL;
@@ -659,7 +659,7 @@ static PyObject *M_Noise_hybrid_multi_fractal(PyObject *UNUSED(self), PyObject *
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
float H, lac, oct, ofs, gn; float H, lac, oct, ofs, gn;
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "Offfff|i:hybrid_multi_fractal", &value, &H, &lac, &oct, &ofs, &gn, &nb)) if (!PyArg_ParseTuple(args, "Offfff|i:hybrid_multi_fractal", &value, &H, &lac, &oct, &ofs, &gn, &nb))
return NULL; return NULL;
@@ -697,7 +697,7 @@ static PyObject *M_Noise_ridged_multi_fractal(PyObject *UNUSED(self), PyObject *
PyObject *value; PyObject *value;
float vec[3]; float vec[3];
float H, lac, oct, ofs, gn; float H, lac, oct, ofs, gn;
int nb= 1; int nb = 1;
if (!PyArg_ParseTuple(args, "Offfff|i:ridged_multi_fractal", &value, &H, &lac, &oct, &ofs, &gn, &nb)) if (!PyArg_ParseTuple(args, "Offfff|i:ridged_multi_fractal", &value, &H, &lac, &oct, &ofs, &gn, &nb))
return NULL; return NULL;
@@ -728,8 +728,8 @@ static PyObject *M_Noise_voronoi(PyObject *UNUSED(self), PyObject *args)
PyObject *list; PyObject *list;
float vec[3]; float vec[3];
float da[4], pa[12]; float da[4], pa[12];
int dtype= 0; int dtype = 0;
float me= 2.5f; /* default minkovsky exponent */ float me = 2.5f; /* default minkovsky exponent */
int i; int i;
@@ -739,12 +739,12 @@ static PyObject *M_Noise_voronoi(PyObject *UNUSED(self), PyObject *args)
if (mathutils_array_parse(vec, 3, 3, value, "voronoi: invalid 'position' arg") == -1) if (mathutils_array_parse(vec, 3, 3, value, "voronoi: invalid 'position' arg") == -1)
return NULL; return NULL;
list= PyList_New(4); list = PyList_New(4);
voronoi(vec[0], vec[1], vec[2], da, pa, me, dtype); voronoi(vec[0], vec[1], vec[2], da, pa, me, dtype);
for (i=0; i<4; i++) { for (i = 0; i < 4; i++) {
PyList_SET_ITEM(list, i, Vector_CreatePyObject(pa + 3*i, 3, Py_NEW, NULL)); PyList_SET_ITEM(list, i, Vector_CreatePyObject(pa + 3 * i, 3, Py_NEW, NULL));
} }
return Py_BuildValue("[[ffff]O]", da[0], da[1], da[2], da[3], list); return Py_BuildValue("[[ffff]O]", da[0], da[1], da[2], da[3], list);
@@ -841,11 +841,11 @@ PyMODINIT_FUNC PyInit_mathutils_noise(void)
/* use current time as seed for random number generator by default */ /* use current time as seed for random number generator by default */
setRndSeed(0); setRndSeed(0);
PyModule_AddObject(submodule, "types", (item_types=PyInit_mathutils_noise_types())); PyModule_AddObject(submodule, "types", (item_types = PyInit_mathutils_noise_types()));
PyDict_SetItemString(PyThreadState_GET()->interp->modules, "noise.types", item_types); PyDict_SetItemString(PyThreadState_GET()->interp->modules, "noise.types", item_types);
Py_INCREF(item_types); Py_INCREF(item_types);
PyModule_AddObject(submodule, "distance_metrics", (item_metrics=PyInit_mathutils_noise_metrics())); PyModule_AddObject(submodule, "distance_metrics", (item_metrics = PyInit_mathutils_noise_metrics()));
PyDict_SetItemString(PyThreadState_GET()->interp->modules, "noise.distance_metrics", item_metrics); PyDict_SetItemString(PyThreadState_GET()->interp->modules, "noise.distance_metrics", item_metrics);
Py_INCREF(item_metrics); Py_INCREF(item_metrics);