size= PySequence_Fast_GET_SIZE(value_fast);
if(size > array_max || size < array_min) {
- if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
- else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
+ if (array_max == array_min) {
+ PyErr_Format(PyExc_ValueError,
+ "%.200s: sequence size is %d, expected %d",
+ error_prefix, size, array_max);
+ }
+ else {
+ PyErr_Format(PyExc_ValueError,
+ "%.200s: sequence size is %d, expected [%d - %d]",
+ error_prefix, size, array_min, array_max);
+ }
Py_DECREF(value_fast);
return -1;
}
do {
i--;
if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) && PyErr_Occurred()) {
- PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d expected a number, found '%.200s' type, ", error_prefix, i, Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_ValueError,
+ "%.200s: sequence index %d expected a number, "
+ "found '%.200s' type, ",
+ error_prefix, i, Py_TYPE(item)->tp_name);
Py_DECREF(value_fast);
return -1;
}
}
if(size > array_max || size < array_min) {
- if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
- else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
+ if (array_max == array_min) {
+ PyErr_Format(PyExc_ValueError,
+ "%.200s: sequence size is %d, expected %d",
+ error_prefix, size, array_max);
+ }
+ else {
+ PyErr_Format(PyExc_ValueError,
+ "%.200s: sequence size is %d, expected [%d - %d]",
+ error_prefix, size, array_min, array_max);
+ }
return -1;
}
return -1;
}
else if(((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) {
- PyErr_Format(PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
+ PyErr_Format(PyExc_ValueError,
+ "%.200s: matrix must have minimum 3x3 dimensions",
+ error_prefix);
return -1;
}
else {
}
}
else {
- PyErr_Format(PyExc_TypeError, "%.200s: expected a Euler, Quaternion or Matrix type, found %.200s", error_prefix, Py_TYPE(value)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "%.200s: expected a Euler, Quaternion or Matrix type, "
+ "found %.200s", error_prefix, Py_TYPE(value)->tp_name);
return -1;
}
}
if(cb->get(self, self->cb_subtype) != -1)
return 0;
- if(!PyErr_Occurred())
- PyErr_Format(PyExc_RuntimeError, "%s read, user has become invalid", Py_TYPE(self)->tp_name);
+ if(!PyErr_Occurred()) {
+ PyErr_Format(PyExc_RuntimeError,
+ "%s read, user has become invalid",
+ Py_TYPE(self)->tp_name);
+ }
return -1;
}
if(cb->set(self, self->cb_subtype) != -1)
return 0;
- if(!PyErr_Occurred())
- PyErr_Format(PyExc_RuntimeError, "%s write, user has become invalid", Py_TYPE(self)->tp_name);
+ if(!PyErr_Occurred()) {
+ PyErr_Format(PyExc_RuntimeError,
+ "%s write, user has become invalid",
+ Py_TYPE(self)->tp_name);
+ }
return -1;
}
if(cb->get_index(self, self->cb_subtype, index) != -1)
return 0;
- if(!PyErr_Occurred())
- PyErr_Format(PyExc_RuntimeError, "%s read index, user has become invalid", Py_TYPE(self)->tp_name);
+ if(!PyErr_Occurred()) {
+ PyErr_Format(PyExc_RuntimeError,
+ "%s read index, user has become invalid",
+ Py_TYPE(self)->tp_name);
+ }
return -1;
}
if(cb->set_index(self, self->cb_subtype, index) != -1)
return 0;
- if(!PyErr_Occurred())
- PyErr_Format(PyExc_RuntimeError, "%s write index, user has become invalid", Py_TYPE(self)->tp_name);
+ if(!PyErr_Occurred()) {
+ PyErr_Format(PyExc_RuntimeError,
+ "%s write index, user has become invalid",
+ Py_TYPE(self)->tp_name);
+ }
return -1;
}
float col[3]= {0.0f, 0.0f, 0.0f};
if(kwds && PyDict_Size(kwds)) {
- PyErr_SetString(PyExc_TypeError, "mathutils.Color(): takes no keyword args");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Color(): "
+ "takes no keyword args");
return NULL;
}
return NULL;
break;
default:
- PyErr_SetString(PyExc_TypeError, "mathutils.Color(): more then a single arg given");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Color(): "
+ "more then a single arg given");
return NULL;
}
return newColorObject(col, Py_NEW, type);
if(i<0) i= COLOR_SIZE-i;
if(i < 0 || i >= COLOR_SIZE) {
- PyErr_SetString(PyExc_IndexError, "color[attribute]: array index out of range");
+ PyErr_SetString(PyExc_IndexError,
+ "color[attribute]: "
+ "array index out of range");
return NULL;
}
float f = PyFloat_AsDouble(value);
if(f == -1 && PyErr_Occurred()) { // parsed item not a number
- PyErr_SetString(PyExc_TypeError, "color[attribute] = x: argument not a number");
+ PyErr_SetString(PyExc_TypeError,
+ "color[attribute] = x: "
+ "argument not a number");
return -1;
}
if(i<0) i= COLOR_SIZE-i;
if(i < 0 || i >= COLOR_SIZE){
- PyErr_SetString(PyExc_IndexError, "color[attribute] = x: array assignment index out of range");
+ PyErr_SetString(PyExc_IndexError, "color[attribute] = x: "
+ "array assignment index out of range");
return -1;
}
return -1;
if(size != (end - begin)){
- PyErr_SetString(PyExc_TypeError, "color[begin:end] = []: size mismatch in slice assignment");
+ PyErr_SetString(PyExc_TypeError,
+ "color[begin:end] = []: "
+ "size mismatch in slice assignment");
return -1;
}
return Color_slice(self, start, stop);
}
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with color");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with color");
return NULL;
}
}
else {
- PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "color indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return NULL;
}
}
if (step == 1)
return Color_ass_slice(self, start, stop, value);
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with color");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with color");
return -1;
}
}
else {
- PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "color indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return -1;
}
}
float col[COLOR_SIZE];
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Color addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Color addition: "
+ "arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
ColorObject *color1 = NULL, *color2 = NULL;
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Color addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Color addition: "
+ "arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
float col[COLOR_SIZE];
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Color subtraction: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Color subtraction: "
+ "arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
ColorObject *color1= NULL, *color2= NULL;
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Color subtraction: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Color subtraction: "
+ "arguments not valid for this operation");
return NULL;
}
color1 = (ColorObject*)v1;
BLI_assert(!"internal error");
}
- PyErr_Format(PyExc_TypeError, "Color multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "Color multiplication: not supported between "
+ "'%.200s' and '%.200s' types",
+ Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL;
}
return NULL;
}
else {
- PyErr_SetString(PyExc_TypeError, "Color division not supported in this order");
+ PyErr_SetString(PyExc_TypeError,
+ "Color division not supported in this order");
return NULL;
}
/* make sure v1 is always the vector */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR * FLOAT */
if(scalar==0.0f) {
- PyErr_SetString(PyExc_ZeroDivisionError, "Color division: divide by zero error");
+ PyErr_SetString(PyExc_ZeroDivisionError,
+ "Color division: divide by zero error");
return NULL;
}
return color_mul_float(color1, 1.0f / scalar);
}
- PyErr_Format(PyExc_TypeError, "Color multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "Color multiplication: not supported between "
+ "'%.200s' and '%.200s' types",
+ Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL;
}
/* only support color /= float */
if (((scalar= PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred())==0) { /* COLOR /= FLOAT */
if(scalar==0.0f) {
- PyErr_SetString(PyExc_ZeroDivisionError, "Color division: divide by zero error");
+ PyErr_SetString(PyExc_ZeroDivisionError,
+ "Color division: divide by zero error");
return NULL;
}
mul_vn_fl(color->col, COLOR_SIZE, 1.0f / scalar);
}
else {
- PyErr_SetString(PyExc_TypeError, "Color multiplication: arguments not acceptable for this operation");
+ PyErr_SetString(PyExc_TypeError,
+ "Color multiplication: "
+ "arguments not acceptable for this operation");
return NULL;
}
float f = PyFloat_AsDouble(value);
if(f == -1 && PyErr_Occurred()) {
- PyErr_SetString(PyExc_TypeError, "color.h/s/v = value: argument not a number");
+ PyErr_SetString(PyExc_TypeError,
+ "color.h/s/v = value: "
+ "argument not a number");
return -1;
}
self->wrapped = Py_NEW;
}
else {
- PyErr_SetString(PyExc_RuntimeError, "Color(): invalid type");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Color(): invalid type, internal error");
return NULL;
}
}
short order= EULER_ORDER_XYZ;
if(kwds && PyDict_Size(kwds)) {
- PyErr_SetString(PyExc_TypeError, "mathutils.Euler(): takes no keyword args");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Euler(): "
+ "takes no keyword args");
return NULL;
}
}
}
- PyErr_Format(PyExc_TypeError, "%s: invalid euler order '%s'", error_prefix, str);
+ PyErr_Format(PyExc_TypeError,
+ "%s: invalid euler order '%s'",
+ error_prefix, str);
return -1;
}
const char *axis;
if(!PyArg_ParseTuple(args, "sf:rotate", &axis, &angle)){
- PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected angle (float) and axis (x, y, z)");
+ PyErr_SetString(PyExc_TypeError,
+ "euler.rotate(): "
+ "expected angle (float) and axis (x, y, z)");
return NULL;
}
if(!(ELEM3(*axis, 'X', 'Y', 'Z') && axis[1]=='\0')){
- PyErr_SetString(PyExc_TypeError, "euler.rotate(): expected axis to be 'X', 'Y' or 'Z'");
+ PyErr_SetString(PyExc_TypeError, "euler.rotate(): "
+ "expected axis to be 'X', 'Y' or 'Z'");
return NULL;
}
if(i<0) i= EULER_SIZE-i;
if(i < 0 || i >= EULER_SIZE) {
- PyErr_SetString(PyExc_IndexError, "euler[attribute]: array index out of range");
+ PyErr_SetString(PyExc_IndexError,
+ "euler[attribute]: "
+ "array index out of range");
return NULL;
}
float f = PyFloat_AsDouble(value);
if(f == -1 && PyErr_Occurred()) { // parsed item not a number
- PyErr_SetString(PyExc_TypeError, "euler[attribute] = x: argument not a number");
+ PyErr_SetString(PyExc_TypeError,
+ "euler[attribute] = x: "
+ "argument not a number");
return -1;
}
if(i<0) i= EULER_SIZE-i;
if(i < 0 || i >= EULER_SIZE){
- PyErr_SetString(PyExc_IndexError, "euler[attribute] = x: array assignment index out of range");
+ PyErr_SetString(PyExc_IndexError,
+ "euler[attribute] = x: "
+ "array assignment index out of range");
return -1;
}
return -1;
if(size != (end - begin)){
- PyErr_SetString(PyExc_TypeError, "euler[begin:end] = []: size mismatch in slice assignment");
+ PyErr_SetString(PyExc_TypeError,
+ "euler[begin:end] = []: "
+ "size mismatch in slice assignment");
return -1;
}
return Euler_slice(self, start, stop);
}
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with eulers");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with eulers");
return NULL;
}
}
else {
- PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "euler indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return NULL;
}
}
if (step == 1)
return Euler_ass_slice(self, start, stop, value);
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with euler");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with euler");
return -1;
}
}
else {
- PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "euler indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return -1;
}
}
self->wrapped = Py_NEW;
}
else {
- PyErr_SetString(PyExc_RuntimeError, "Euler(): invalid type");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Euler(): invalid type, internal error");
return NULL;
}
static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
if(kwds && PyDict_Size(kwds)) {
- PyErr_SetString(PyExc_TypeError, "mathutils.Matrix(): takes no keyword args");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Matrix(): "
+ "takes no keyword args");
return NULL;
}
{
PyObject *arg= PyTuple_GET_ITEM(args, 0);
- const unsigned short row_size= PySequence_Size(arg); /* -1 is an error, size checks will accunt for this */
+ /* -1 is an error, size checks will accunt for this */
+ const unsigned short row_size= PySequence_Size(arg);
if(row_size >= 2 && row_size <= 4) {
PyObject *item= PySequence_GetItem(arg, 0);
}
/* will overwrite error */
- PyErr_SetString(PyExc_TypeError, "mathutils.Matrix(): expects no args or 2-4 numeric sequences");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Matrix(): "
+ "expects no args or 2-4 numeric sequences");
return NULL;
}
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
if(!PyArg_ParseTuple(args, "di|O", &angle, &matSize, &vec)) {
- PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(angle, size, axis): expected float int and a string or vector");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.RotationMatrix(angle, size, axis): "
+ "expected float int and a string or vector");
return NULL;
}
if(vec && PyUnicode_Check(vec)) {
axis= _PyUnicode_AsString((PyObject *)vec);
if(axis==NULL || axis[0]=='\0' || axis[1]!='\0' || axis[0] < 'X' || axis[0] > 'Z') {
- PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(): 3rd argument axis value must be a 3D vector or a string in 'X', 'Y', 'Z'");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.RotationMatrix(): "
+ "3rd argument axis value must be a 3D vector "
+ "or a string in 'X', 'Y', 'Z'");
return NULL;
}
else {
angle= angle_wrap_rad(angle);
if(matSize != 2 && matSize != 3 && matSize != 4) {
- PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): can only return a 2x2 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.RotationMatrix(): "
+ "can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
if(matSize == 2 && (vec != NULL)) {
- PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): cannot create a 2x2 rotation matrix around arbitrary axis");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.RotationMatrix(): "
+ "cannot create a 2x2 rotation matrix around arbitrary axis");
return NULL;
}
if((matSize == 3 || matSize == 4) && (axis == NULL) && (vec == NULL)) {
- PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): axis of rotation for 3d and 4d matrices is required");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.RotationMatrix(): "
+ "axis of rotation for 3d and 4d matrices is required");
return NULL;
}
}
else {
/* should never get here */
- PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): unknown error");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.RotationMatrix(): unknown error");
return NULL;
}
return NULL;
}
if(matSize != 2 && matSize != 3 && matSize != 4) {
- PyErr_SetString(PyExc_AttributeError, "Matrix.Scale(): can only return a 2x2 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix.Scale(): "
+ "can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
if(vec) {
if(matSize == 2) {
mat[0] = factor;
mat[3] = factor;
- } else {
+ }
+ else {
mat[0] = factor;
mat[4] = factor;
mat[8] = factor;
mat[1] = ((factor - 1) *(tvec[0] * tvec[1]));
mat[2] = ((factor - 1) *(tvec[0] * tvec[1]));
mat[3] = 1 + ((factor - 1) *(tvec[1] * tvec[1]));
- } else {
+ }
+ else {
mat[0] = 1 + ((factor - 1) *(tvec[0] * tvec[0]));
mat[1] = ((factor - 1) *(tvec[0] * tvec[1]));
mat[2] = ((factor - 1) *(tvec[0] * tvec[2]));
return NULL;
}
if(matSize != 2 && matSize != 3 && matSize != 4) {
- PyErr_SetString(PyExc_AttributeError,"mathutils.Matrix.OrthoProjection(): can only return a 2x2 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.Matrix.OrthoProjection(): "
+ "can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
mat[3]= 1.0f;
}
else {
- PyErr_Format(PyExc_ValueError, "mathutils.Matrix.OrthoProjection(): unknown plane, expected: X, Y, not '%.200s'", plane);
+ PyErr_Format(PyExc_ValueError,
+ "mathutils.Matrix.OrthoProjection(): "
+ "unknown plane, expected: X, Y, not '%.200s'",
+ plane);
return NULL;
}
}
mat[8]= 1.0f;
}
else {
- PyErr_Format(PyExc_ValueError, "mathutils.Matrix.OrthoProjection(): unknown plane, expected: XY, XZ, YZ, not '%.200s'", plane);
+ PyErr_Format(PyExc_ValueError,
+ "mathutils.Matrix.OrthoProjection(): "
+ "unknown plane, expected: XY, XZ, YZ, not '%.200s'",
+ plane);
return NULL;
}
}
return NULL;
}
if(matSize != 2 && matSize != 3 && matSize != 4) {
- PyErr_SetString(PyExc_AttributeError,"mathutils.Matrix.Shear(): can only return a 2x2 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.Matrix.Shear(): "
+ "can only return a 2x2 3x3 or 4x4 matrix");
return NULL;
}
float const factor= PyFloat_AsDouble(fac);
if(factor==-1.0f && PyErr_Occurred()) {
- PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix.Shear(): the factor to be a float");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.Matrix.Shear(): "
+ "the factor to be a float");
return NULL;
}
mat[1] = factor;
}
else {
- PyErr_SetString(PyExc_AttributeError, "Matrix.Shear(): expected: X, Y or wrong matrix size for shearing plane");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix.Shear(): "
+ "expected: X, Y or wrong matrix size for shearing plane");
return NULL;
}
}
mat[2] = factor[1];
}
else {
- PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix.Shear(): expected: X, Y, XY, XZ, YZ");
+ PyErr_SetString(PyExc_AttributeError,
+ "mathutils.Matrix.Shear(): "
+ "expected: X, Y, XY, XZ, YZ");
return NULL;
}
}
self->matrix[1][1], self->matrix[1][2],
self->matrix[2][0], self->matrix[2][1],
self->matrix[2][2]);
- } else {
+ }
+ else {
return determinant_m4((float (*)[4])self->contigPtr);
}
}
/*must be 3-4 cols, 3-4 rows, square matrix*/
if((self->col_size < 3) || (self->row_size < 3) || (self->col_size != self->row_size)) {
- PyErr_SetString(PyExc_AttributeError, "Matrix.to_quat(): inappropriate matrix size - expects 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.to_quat(): "
+ "inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
if(self->col_size == 3){
return newQuaternionObject(quat, Py_NEW, NULL);
}
-/*---------------------------Matrix.toEuler() --------------------*/
+/*---------------------------matrix.toEuler() --------------------*/
PyDoc_STRVAR(Matrix_to_euler_doc,
".. method:: to_euler(order, euler_compat)\n"
"\n"
mat= tmat;
}
else {
- PyErr_SetString(PyExc_AttributeError, "Matrix.to_euler(): inappropriate matrix size - expects 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.to_euler(): "
+ "inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
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)
return NULL;
int x, first_row_elem, curr_pos, new_pos, blank_columns, blank_rows, index;
if(self->wrapped==Py_WRAP){
- PyErr_SetString(PyExc_TypeError, "cannot resize wrapped data - make a copy and resize that");
+ PyErr_SetString(PyExc_TypeError,
+ "cannot resize wrapped data - make a copy and resize that");
return NULL;
}
if(self->cb_user){
- PyErr_SetString(PyExc_TypeError, "cannot resize owned data - make a copy and resize that");
+ PyErr_SetString(PyExc_TypeError,
+ "cannot resize owned data - make a copy and resize that");
return NULL;
}
self->contigPtr = PyMem_Realloc(self->contigPtr, (sizeof(float) * 16));
if(self->contigPtr == NULL) {
- PyErr_SetString(PyExc_MemoryError, "matrix.resize_4x4(): problem allocating pointer space");
+ PyErr_SetString(PyExc_MemoryError,
+ "matrix.resize_4x4(): problem allocating pointer space");
return NULL;
}
/*set row pointers*/
}
/* TODO, 2x2 matrix */
- PyErr_SetString(PyExc_TypeError, "Matrix.to_4x4(): inappropriate matrix size");
+ PyErr_SetString(PyExc_TypeError,
+ "matrix.to_4x4(): inappropriate matrix size");
return NULL;
}
return NULL;
if((self->col_size < 3) || (self->row_size < 3)) {
- PyErr_SetString(PyExc_AttributeError, "Matrix.to_3x3(): inappropriate matrix size");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.to_3x3(): inappropriate matrix size");
return NULL;
}
return NULL;
if((self->col_size < 3) || self->row_size < 4){
- PyErr_SetString(PyExc_AttributeError, "Matrix.to_translation(): inappropriate matrix size");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.to_translation(): "
+ "inappropriate matrix size");
return NULL;
}
/*must be 3-4 cols, 3-4 rows, square matrix*/
if((self->col_size < 3) || (self->row_size < 3)) {
- PyErr_SetString(PyExc_AttributeError, "Matrix.to_scale(): inappropriate matrix size, 3x3 minimum size");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.to_scale(): "
+ "inappropriate matrix size, 3x3 minimum size");
return NULL;
}
return newVectorObject(size, 3, Py_NEW, NULL);
}
-/*---------------------------Matrix.invert() ---------------------*/
+/*---------------------------matrix.invert() ---------------------*/
PyDoc_STRVAR(Matrix_invert_doc,
".. method:: invert()\n"
"\n"
return NULL;
if(self->row_size != self->col_size){
- PyErr_SetString(PyExc_AttributeError, "Matrix.invert(ed): only square matrices are supported");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.invert(ed): "
+ "only square matrices are supported");
return NULL;
}
}
/*transpose
Matrix_transpose(self);*/
- } else {
- PyErr_SetString(PyExc_ValueError, "matrix does not have an inverse");
+ }
+ else {
+ PyErr_SetString(PyExc_ValueError,
+ "matrix does not have an inverse");
return NULL;
}
return NULL;
if(self->col_size != 3 || self->row_size != 3) {
- PyErr_SetString(PyExc_ValueError, "Matrix must have 3x3 dimensions");
+ PyErr_SetString(PyExc_ValueError,
+ "Matrix must have 3x3 dimensions");
return NULL;
}
Py_RETURN_NONE;
}
-/*---------------------------Matrix.decompose() ---------------------*/
+/*---------------------------matrix.decompose() ---------------------*/
PyDoc_STRVAR(Matrix_decompose_doc,
".. method:: decompose()\n"
"\n"
float size[3];
if(self->col_size != 4 || self->row_size != 4) {
- PyErr_SetString(PyExc_AttributeError, "Matrix.decompose(): inappropriate matrix size - expects 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.decompose(): "
+ "inappropriate matrix size - expects 4x4 matrix");
return NULL;
}
return NULL;
if(self->row_size != mat2->row_size || self->col_size != mat2->col_size) {
- PyErr_SetString(PyExc_AttributeError, "matrix.lerp(): expects both matrix objects of the same dimensions");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.lerp(): "
+ "expects both matrix objects of the same dimensions");
return NULL;
}
blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->contigPtr, (float (*)[3])mat2->contigPtr, fac);
}
else {
- PyErr_SetString(PyExc_AttributeError, "matrix.lerp(): only 3x3 and 4x4 matrices supported");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.lerp(): "
+ "only 3x3 and 4x4 matrices supported");
return NULL;
}
return (PyObject*)newMatrixObject(mat, self->row_size, self->col_size, Py_NEW, Py_TYPE(self));
}
-/*---------------------------Matrix.determinant() ----------------*/
+/*---------------------------matrix.determinant() ----------------*/
PyDoc_STRVAR(Matrix_determinant_doc,
".. method:: determinant()\n"
"\n"
return NULL;
if(self->row_size != self->col_size){
- PyErr_SetString(PyExc_AttributeError, "Matrix.determinant: only square matrices are supported");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.determinant: "
+ "only square matrices are supported");
return NULL;
}
return PyFloat_FromDouble((double)matrix_determinant_internal(self));
}
-/*---------------------------Matrix.transpose() ------------------*/
+/*---------------------------matrix.transpose() ------------------*/
PyDoc_STRVAR(Matrix_transpose_doc,
".. method:: transpose()\n"
"\n"
return NULL;
if(self->row_size != self->col_size){
- PyErr_SetString(PyExc_AttributeError, "Matrix.transpose(d): only square matrices are supported");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.transpose(d): "
+ "only square matrices are supported");
return NULL;
}
self->matrix[0][1] = t;
} else if(self->row_size == 3) {
transpose_m3((float (*)[3])self->contigPtr);
- } else {
+ }
+ else {
transpose_m4((float (*)[4])self->contigPtr);
}
return matrix__apply_to_copy((PyNoArgsFunction)Matrix_transpose, self);
}
-/*---------------------------Matrix.zero() -----------------------*/
+/*---------------------------matrix.zero() -----------------------*/
PyDoc_STRVAR(Matrix_zero_doc,
".. method:: zero()\n"
"\n"
Py_RETURN_NONE;
}
-/*---------------------------Matrix.identity(() ------------------*/
+/*---------------------------matrix.identity(() ------------------*/
PyDoc_STRVAR(Matrix_identity_doc,
".. method:: identity()\n"
"\n"
return NULL;
if(self->row_size != self->col_size){
- PyErr_SetString(PyExc_AttributeError, "Matrix.identity: only square matrices are supported");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.identity: "
+ "only square matrices are supported");
return NULL;
}
self->matrix[1][1] = 1.0f;
} else if(self->row_size == 3) {
unit_m3((float (*)[3])self->contigPtr);
- } else {
+ }
+ else {
unit_m4((float (*)[4])self->contigPtr);
}
" %R)", rows[0], rows[1], rows[2], rows[3]);
}
- PyErr_SetString(PyExc_RuntimeError, "invalid matrix size");
+ PyErr_SetString(PyExc_RuntimeError,
+ "internal error!");
return NULL;
}
return NULL;
if(i < 0 || i >= self->row_size) {
- PyErr_SetString(PyExc_IndexError, "matrix[attribute]: array index out of range");
+ PyErr_SetString(PyExc_IndexError,
+ "matrix[attribute]: "
+ "array index out of range");
return NULL;
}
return newVectorObject_cb((PyObject *)self, self->col_size, mathutils_matrix_vector_cb_index, i);
return -1;
if(i >= self->row_size || i < 0){
- PyErr_SetString(PyExc_TypeError, "matrix[attribute] = x: bad column");
+ PyErr_SetString(PyExc_TypeError,
+ "matrix[attribute] = x: bad column");
return -1;
}
if(PySequence_Fast_GET_SIZE(value_fast) != size) {
Py_DECREF(value_fast);
- PyErr_SetString(PyExc_TypeError, "matrix[begin:end] = []: size mismatch in slice assignment");
+ PyErr_SetString(PyExc_TypeError,
+ "matrix[begin:end] = []: "
+ "size mismatch in slice assignment");
return -1;
}
mat2 = (MatrixObject*)m2;
if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
- PyErr_SetString(PyExc_AttributeError, "Matrix addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix addition: "
+ "arguments not valid for this operation");
return NULL;
}
return NULL;
if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){
- PyErr_SetString(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix addition: "
+ "matrices must have the same dimensions for this operation");
return NULL;
}
mat2 = (MatrixObject*)m2;
if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
- PyErr_SetString(PyExc_AttributeError, "Matrix addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix addition: "
+ "arguments not valid for this operation");
return NULL;
}
return NULL;
if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){
- PyErr_SetString(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix addition: "
+ "matrices must have the same dimensions for this operation");
return NULL;
}
return NULL;
}
- if(mat1 && mat2) { /*MATRIX * MATRIX*/
+ if(mat1 && mat2) {
+ /*MATRIX * MATRIX*/
if(mat1->row_size != mat2->col_size){
- PyErr_SetString(PyExc_AttributeError,"Matrix multiplication: matrix A rowsize must equal matrix B colsize");
+ PyErr_SetString(PyExc_AttributeError,
+ "Matrix multiplication: "
+ "matrix A rowsize must equal matrix B colsize");
return NULL;
}
else {
}
}
else if(mat2) {
- if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) { /*FLOAT/INT * MATRIX */
+ /*FLOAT/INT * MATRIX */
+ if (((scalar= PyFloat_AsDouble(m1)) == -1.0f && PyErr_Occurred())==0) {
return matrix_mul_float(mat2, scalar);
}
}
else if(mat1) {
- if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) { /*FLOAT/INT * MATRIX */
+ /*FLOAT/INT * MATRIX */
+ if (((scalar= PyFloat_AsDouble(m2)) == -1.0f && PyErr_Occurred())==0) {
return matrix_mul_float(mat1, scalar);
}
}
BLI_assert(!"internal error");
}
- PyErr_Format(PyExc_TypeError, "Matrix multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "Matrix multiplication: "
+ "not supported between '%.200s' and '%.200s' types",
+ Py_TYPE(m1)->tp_name, Py_TYPE(m2)->tp_name);
return NULL;
}
static PyObject* Matrix_inv(MatrixObject *self)
return Matrix_slice(self, start, stop);
}
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with matricies");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with matricies");
return NULL;
}
}
else {
- PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "vector indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return NULL;
}
}
if (step == 1)
return Matrix_ass_slice(self, start, stop, value);
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with matricies");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with matricies");
return -1;
}
}
else {
- PyErr_Format(PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "matrix indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return -1;
}
}
/*must be 3-4 cols, 3-4 rows, square matrix*/
if((self->col_size < 3) || (self->row_size < 3)) {
- PyErr_SetString(PyExc_AttributeError, "Matrix.median_scale: inappropriate matrix size, 3x3 minimum");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.median_scale: "
+ "inappropriate matrix size, 3x3 minimum");
return NULL;
}
else if(self->col_size == 3 && self->row_size == 3)
return PyBool_FromLong(is_negative_m3((float (*)[3])self->contigPtr));
else {
- PyErr_SetString(PyExc_AttributeError, "Matrix.is_negative: inappropriate matrix size - expects 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.is_negative: "
+ "inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
}
else if(self->col_size == 3 && self->row_size == 3)
return PyBool_FromLong(is_orthogonal_m3((float (*)[3])self->contigPtr));
else {
- PyErr_SetString(PyExc_AttributeError, "Matrix.is_orthogonal: inappropriate matrix size - expects 3x3 or 4x4 matrix");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix.is_orthogonal: "
+ "inappropriate matrix size - expects 3x3 or 4x4 matrix");
return NULL;
}
}
/*matrix objects can be any 2-4row x 2-4col matrix*/
if(rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4) {
- PyErr_SetString(PyExc_RuntimeError, "matrix(): row and column sizes must be between 2 and 4");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Matrix(): "
+ "row and column sizes must be between 2 and 4");
return NULL;
}
else if (type == Py_NEW){
self->contigPtr = PyMem_Malloc(rowSize * colSize * sizeof(float));
if(self->contigPtr == NULL) { /*allocation failure*/
- PyErr_SetString(PyExc_MemoryError, "matrix(): problem allocating pointer space");
+ PyErr_SetString(PyExc_MemoryError,
+ "Matrix(): "
+ "problem allocating pointer space");
return NULL;
}
/*pointer array points to contigous memory*/
self->wrapped = Py_NEW;
}
else {
- PyErr_SetString(PyExc_RuntimeError, "Matrix(): invalid type");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Matrix(): invalid type, internal error");
return NULL;
}
}
float tquat[QUAT_SIZE], quat[QUAT_SIZE], fac;
if(!PyArg_ParseTuple(args, "Of:slerp", &value, &fac)) {
- PyErr_SetString(PyExc_TypeError, "quat.slerp(): expected Quaternion types and float");
+ PyErr_SetString(PyExc_TypeError,
+ "quat.slerp(): "
+ "expected Quaternion types and float");
return NULL;
}
return NULL;
if(fac > 1.0f || fac < 0.0f) {
- PyErr_SetString(PyExc_AttributeError, "quat.slerp(): interpolation factor must be between 0.0 and 1.0");
+ PyErr_SetString(PyExc_AttributeError,
+ "quat.slerp(): "
+ "interpolation factor must be between 0.0 and 1.0");
return NULL;
}
if(i<0) i= QUAT_SIZE-i;
if(i < 0 || i >= QUAT_SIZE) {
- PyErr_SetString(PyExc_IndexError, "quaternion[attribute]: array index out of range");
+ PyErr_SetString(PyExc_IndexError,
+ "quaternion[attribute]: "
+ "array index out of range");
return NULL;
}
{
float scalar= (float)PyFloat_AsDouble(ob);
if(scalar==-1.0f && PyErr_Occurred()) { /* parsed item not a number */
- PyErr_SetString(PyExc_TypeError, "quaternion[index] = x: index argument not a number");
+ PyErr_SetString(PyExc_TypeError,
+ "quaternion[index] = x: "
+ "index argument not a number");
return -1;
}
if(i<0) i= QUAT_SIZE-i;
if(i < 0 || i >= QUAT_SIZE){
- PyErr_SetString(PyExc_IndexError, "quaternion[attribute] = x: array assignment index out of range");
+ PyErr_SetString(PyExc_IndexError,
+ "quaternion[attribute] = x: "
+ "array assignment index out of range");
return -1;
}
self->quat[i] = scalar;
return -1;
if(size != (end - begin)){
- PyErr_SetString(PyExc_TypeError, "quaternion[begin:end] = []: size mismatch in slice assignment");
+ PyErr_SetString(PyExc_TypeError,
+ "quaternion[begin:end] = []: "
+ "size mismatch in slice assignment");
return -1;
}
return Quaternion_slice(self, start, stop);
}
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with quaternions");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with quaternions");
return NULL;
}
}
else {
- PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "quaternion indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return NULL;
}
}
if (step == 1)
return Quaternion_ass_slice(self, start, stop, value);
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with quaternion");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with quaternion");
return -1;
}
}
else {
- PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "quaternion indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return -1;
}
}
QuaternionObject *quat1 = NULL, *quat2 = NULL;
if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) {
- PyErr_SetString(PyExc_AttributeError, "Quaternion addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Quaternion addition: "
+ "arguments not valid for this operation");
return NULL;
}
quat1 = (QuaternionObject*)q1;
QuaternionObject *quat1 = NULL, *quat2 = NULL;
if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) {
- PyErr_SetString(PyExc_AttributeError, "Quaternion addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Quaternion addition: "
+ "arguments not valid for this operation");
return NULL;
}
BLI_assert(!"internal error");
}
- PyErr_Format(PyExc_TypeError, "Quaternion multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(q1)->tp_name, Py_TYPE(q2)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "Quaternion multiplication: "
+ "not supported between '%.200s' and '%.200s' types",
+ Py_TYPE(q1)->tp_name, Py_TYPE(q2)->tp_name);
return NULL;
}
angle= PyFloat_AsDouble(value);
if(angle==-1.0 && PyErr_Occurred()) { /* parsed item not a number */
- PyErr_SetString(PyExc_TypeError, "quaternion.angle = value: float expected");
+ PyErr_SetString(PyExc_TypeError,
+ "quaternion.angle = value: float expected");
return -1;
}
float quat[QUAT_SIZE]= {0.0f, 0.0f, 0.0f, 0.0f};
if(kwds && PyDict_Size(kwds)) {
- PyErr_SetString(PyExc_TypeError, "mathutils.Quaternion(): takes no keyword args");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Quaternion(): "
+ "takes no keyword args");
return NULL;
}
self->wrapped = Py_NEW;
}
else {
- PyErr_SetString(PyExc_RuntimeError, "Quaternion(): invalid type");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Quaternion(): invalid type, internal error");
return NULL;
}
}
return NULL;
break;
default:
- PyErr_SetString(PyExc_TypeError, "mathutils.Vector(): more then a single arg given");
+ PyErr_SetString(PyExc_TypeError,
+ "mathutils.Vector(): "
+ "more then a single arg given");
return NULL;
}
return newVectorObject(vec, size, Py_NEW, type);
static PyObject *Vector_resize_2d(VectorObject *self)
{
if(self->wrapped==Py_WRAP) {
- PyErr_SetString(PyExc_TypeError, "vector.resize_2d(): cannot resize wrapped data - only python vectors");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.resize_2d(): "
+ "cannot resize wrapped data - only python vectors");
return NULL;
}
if(self->cb_user) {
- PyErr_SetString(PyExc_TypeError, "vector.resize_2d(): cannot resize a vector that has an owner");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.resize_2d(): "
+ "cannot resize a vector that has an owner");
return NULL;
}
self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 2));
if(self->vec == NULL) {
- PyErr_SetString(PyExc_MemoryError, "vector.resize_2d(): problem allocating pointer space");
+ PyErr_SetString(PyExc_MemoryError,
+ "vector.resize_2d(): "
+ "problem allocating pointer space");
return NULL;
}
static PyObject *Vector_resize_3d(VectorObject *self)
{
if (self->wrapped==Py_WRAP) {
- PyErr_SetString(PyExc_TypeError, "vector.resize_3d(): cannot resize wrapped data - only python vectors");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.resize_3d(): "
+ "cannot resize wrapped data - only python vectors");
return NULL;
}
if(self->cb_user) {
- PyErr_SetString(PyExc_TypeError, "vector.resize_3d(): cannot resize a vector that has an owner");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.resize_3d(): "
+ "cannot resize a vector that has an owner");
return NULL;
}
self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 3));
if(self->vec == NULL) {
- PyErr_SetString(PyExc_MemoryError, "vector.resize_3d(): problem allocating pointer space");
+ PyErr_SetString(PyExc_MemoryError,
+ "vector.resize_3d(): "
+ "problem allocating pointer space");
return NULL;
}
static PyObject *Vector_resize_4d(VectorObject *self)
{
if(self->wrapped==Py_WRAP) {
- PyErr_SetString(PyExc_TypeError, "vector.resize_4d(): cannot resize wrapped data - only python vectors");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.resize_4d(): "
+ "cannot resize wrapped data - only python vectors");
return NULL;
}
if(self->cb_user) {
- PyErr_SetString(PyExc_TypeError, "vector.resize_4d(): cannot resize a vector that has an owner");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.resize_4d(): "
+ "cannot resize a vector that has an owner");
return NULL;
}
self->vec = PyMem_Realloc(self->vec, (sizeof(float) * 4));
if(self->vec == NULL) {
- PyErr_SetString(PyExc_MemoryError, "vector.resize_4d(): problem allocating pointer space");
+ PyErr_SetString(PyExc_MemoryError,
+ "vector.resize_4d(): "
+ "problem allocating pointer space");
return NULL;
}
return NULL;
if(ndigits > 22 || ndigits < 0) {
- PyErr_SetString(PyExc_ValueError, "vector.to_tuple(ndigits): ndigits must be between 0 and 21");
+ PyErr_SetString(PyExc_ValueError,
+ "vector.to_tuple(ndigits): "
+ "ndigits must be between 0 and 21");
return NULL;
}
return NULL;
if (self->size != 3) {
- PyErr_SetString(PyExc_TypeError, "only for 3D vectors");
+ PyErr_SetString(PyExc_TypeError,
+ "vector.to_track_quat(): "
+ "only for 3D vectors");
return NULL;
}
return NULL;
if (strack) {
+ const char *axis_err_msg= "only X, -X, Y, -Y, Z or -Z for track axis";
+
if (strlen(strack) == 2) {
if (strack[0] == '-') {
switch(strack[1]) {
track = 5;
break;
default:
- PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
+ PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
else {
- PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
+ PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
track = 2;
break;
default:
- PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
+ PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
else {
- PyErr_SetString(PyExc_ValueError, "only X, -X, Y, -Y, Z or -Z for track axis");
+ PyErr_SetString(PyExc_ValueError,
+ axis_err_msg);
return NULL;
}
}
if (sup) {
+ const char *axis_err_msg= "only X, Y or Z for up axis";
if (strlen(sup) == 1) {
switch(*sup) {
case 'X':
up = 2;
break;
default:
- PyErr_SetString(PyExc_ValueError, "only X, Y or Z for up axis");
+ PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
else {
- PyErr_SetString(PyExc_ValueError, "only X, Y or Z for up axis");
+ PyErr_SetString(PyExc_ValueError, axis_err_msg);
return NULL;
}
}
if (track == up) {
- PyErr_SetString(PyExc_ValueError, "Can't have the same axis for track and up");
+ PyErr_SetString(PyExc_ValueError,
+ "Can't have the same axis for track and up");
return NULL;
}
return fallback;
}
else {
- PyErr_SetString(PyExc_ValueError, "vector.angle(other): zero length vectors have no valid angle");
+ PyErr_SetString(PyExc_ValueError,
+ "vector.angle(other): "
+ "zero length vectors have no valid angle");
return NULL;
}
}
float quat[4], vec_a[3], vec_b[3];
if(self->size < 3) {
- PyErr_SetString(PyExc_AttributeError, "vec.difference(value): expects both vectors to be size 3 or 4");
+ PyErr_SetString(PyExc_AttributeError,
+ "vec.difference(value): "
+ "expects both vectors to be size 3 or 4");
return NULL;
}
return NULL;
if(self->size < 3) {
- PyErr_SetString(PyExc_ValueError, "Vector must be 3D or 4D");
+ PyErr_SetString(PyExc_ValueError,
+ "Vector must be 3D or 4D");
return NULL;
}
if(i<0) i= self->size-i;
if(i < 0 || i >= self->size) {
- if(is_attr) PyErr_Format(PyExc_AttributeError,"vector.%c: unavailable on %dd vector", *(((char *)"xyzw") + i), self->size);
- else PyErr_SetString(PyExc_IndexError,"vector[index]: out of range");
+ if(is_attr) {
+ PyErr_Format(PyExc_AttributeError,
+ "vector.%c: unavailable on %dd vector",
+ *(((char *)"xyzw") + i), self->size);
+ }
+ else {
+ PyErr_SetString(PyExc_IndexError,
+ "vector[index]: out of range");
+ }
return NULL;
}
{
float scalar;
if((scalar=PyFloat_AsDouble(value))==-1.0f && PyErr_Occurred()) { /* parsed item not a number */
- PyErr_SetString(PyExc_TypeError, "vector[index] = x: index argument not a number");
+ PyErr_SetString(PyExc_TypeError,
+ "vector[index] = x: "
+ "index argument not a number");
return -1;
}
if(i<0) i= self->size-i;
if(i < 0 || i >= self->size){
- if(is_attr) PyErr_Format(PyExc_AttributeError,"vector.%c = x: unavailable on %dd vector", *(((char *)"xyzw") + i), self->size);
- else PyErr_SetString(PyExc_IndexError, "vector[index] = x: assignment index out of range");
+ if(is_attr) {
+ PyErr_Format(PyExc_AttributeError,
+ "vector.%c = x: unavailable on %dd vector",
+ *(((char *)"xyzw") + i), self->size);
+ }
+ else {
+ PyErr_SetString(PyExc_IndexError,
+ "vector[index] = x: "
+ "assignment index out of range");
+ }
return -1;
}
self->vec[i] = scalar;
float vec[MAX_DIMENSIONS];
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector addition: "
+ "arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
/*VECTOR + VECTOR*/
if(vec1->size != vec2->size) {
- PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector addition: "
+ "vectors must have the same dimensions for this operation");
return NULL;
}
VectorObject *vec1 = NULL, *vec2 = NULL;
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Vector addition: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector addition: "
+ "arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if(vec1->size != vec2->size) {
- PyErr_SetString(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector addition: "
+ "vectors must have the same dimensions for this operation");
return NULL;
}
float vec[MAX_DIMENSIONS];
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector subtraction: "
+ "arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
return NULL;
if(vec1->size != vec2->size) {
- PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector subtraction: "
+ "vectors must have the same dimensions for this operation");
return NULL;
}
VectorObject *vec1= NULL, *vec2= NULL;
if (!VectorObject_Check(v1) || !VectorObject_Check(v2)) {
- PyErr_SetString(PyExc_AttributeError, "Vector subtraction: arguments not valid for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector subtraction: "
+ "arguments not valid for this operation");
return NULL;
}
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if(vec1->size != vec2->size) {
- PyErr_SetString(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector subtraction: "
+ "vectors must have the same dimensions for this operation");
return NULL;
}
vec_cpy[3] = 1.0f;
}
else {
- PyErr_SetString(PyExc_AttributeError, "matrix * vector: matrix.row_size and len(vector) must be the same, except for 3D vector * 4x4 matrix.");
+ PyErr_SetString(PyExc_AttributeError,
+ "matrix * vector: "
+ "matrix.row_size and len(vector) must be the same, "
+ "except for 3D vector * 4x4 matrix.");
return -1;
}
}
double dot = 0.0f;
if(vec1->size != vec2->size) {
- PyErr_SetString(PyExc_AttributeError, "Vector multiplication: vectors must have the same dimensions for this operation");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector multiplication: "
+ "vectors must have the same dimensions for this operation");
return NULL;
}
float tvec[3];
if(vec1->size != 3) {
- PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported");
+ PyErr_SetString(PyExc_TypeError,
+ "Vector multiplication: "
+ "only 3D vector rotations (with quats) currently supported");
return NULL;
}
if(BaseMath_ReadCallback(quat2) == -1) {
BLI_assert(!"internal error");
}
- PyErr_Format(PyExc_TypeError, "Vector multiplication: not supported between '%.200s' and '%.200s' types", Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "Vector multiplication: "
+ "not supported between '%.200s' and '%.200s' types",
+ Py_TYPE(v1)->tp_name, Py_TYPE(v2)->tp_name);
return NULL;
}
QuaternionObject *quat2 = (QuaternionObject*)v2;
if(vec->size != 3) {
- PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported");
+ PyErr_SetString(PyExc_TypeError,
+ "Vector multiplication: "
+ "only 3D vector rotations (with quats) currently supported");
return NULL;
}
mul_vn_fl(vec->vec, vec->size, scalar);
}
else {
- PyErr_SetString(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation");
+ PyErr_SetString(PyExc_TypeError,
+ "Vector multiplication: "
+ "arguments not acceptable for this operation");
return NULL;
}
VectorObject *vec1 = NULL;
if(!VectorObject_Check(v1)) { /* not a vector */
- PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float");
+ PyErr_SetString(PyExc_TypeError,
+ "Vector division: "
+ "Vector must be divided by a float");
return NULL;
}
vec1 = (VectorObject*)v1; /* vector */
return NULL;
if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
- PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float");
+ PyErr_SetString(PyExc_TypeError,
+ "Vector division: "
+ "Vector must be divided by a float");
return NULL;
}
if(scalar==0.0f) {
- PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error");
+ PyErr_SetString(PyExc_ZeroDivisionError,
+ "Vector division: "
+ "divide by zero error");
return NULL;
}
return NULL;
if((scalar=PyFloat_AsDouble(v2)) == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
- PyErr_SetString(PyExc_TypeError, "Vector division: Vector must be divided by a float");
+ PyErr_SetString(PyExc_TypeError,
+ "Vector division: "
+ "Vector must be divided by a float");
return NULL;
}
if(scalar==0.0f) {
- PyErr_SetString(PyExc_ZeroDivisionError, "Vector division: divide by zero error");
+ PyErr_SetString(PyExc_ZeroDivisionError,
+ "Vector division: "
+ "divide by zero error");
return NULL;
}
for(i = 0; i < vec1->size; i++) {
return Vector_slice(self, start, stop);
}
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with vectors");
return NULL;
}
}
else {
- PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "vector indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return NULL;
}
}
if (step == 1)
return Vector_ass_slice(self, start, stop, value);
else {
- PyErr_SetString(PyExc_TypeError, "slice steps not supported with vectors");
+ PyErr_SetString(PyExc_TypeError,
+ "slice steps not supported with vectors");
return -1;
}
}
else {
- PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
+ PyErr_Format(PyExc_TypeError,
+ "vector indices must be integers, not %.200s",
+ Py_TYPE(item)->tp_name);
return -1;
}
}
return -1;
if((param=PyFloat_AsDouble(value)) == -1.0 && PyErr_Occurred()) {
- PyErr_SetString(PyExc_TypeError, "length must be set to a number");
+ PyErr_SetString(PyExc_TypeError,
+ "length must be set to a number");
return -1;
}
if (param < 0.0) {
- PyErr_SetString(PyExc_TypeError, "cannot set a vectors length to a negative value");
+ PyErr_SetString(PyExc_TypeError,
+ "cannot set a vectors length to a negative value");
return -1;
}
if (param == 0.0) {
{
axis_from = swizzleClosure & SWIZZLE_AXIS;
if(axis_from >= self->size) {
- PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector swizzle: "
+ "specified axis not present");
return NULL;
}
swizzles defined for axes z and w, but they would be invalid. */
swizzleClosure = GET_INT_FROM_POINTER(closure);
axis_from= 0;
- while (swizzleClosure & SWIZZLE_VALID_AXIS)
- {
+ while (swizzleClosure & SWIZZLE_VALID_AXIS) {
axis_to = swizzleClosure & SWIZZLE_AXIS;
if (axis_to >= self->size)
{
- PyErr_SetString(PyExc_AttributeError, "Error: vector does not have specified axis");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector swizzle: "
+ "specified axis not present");
return -1;
}
swizzleClosure = swizzleClosure >> SWIZZLE_BITS_PER_AXIS;
}
if(axis_from != size_from) {
- PyErr_SetString(PyExc_AttributeError, "Error: vector size does not match swizzle");
+ PyErr_SetString(PyExc_AttributeError,
+ "Vector swizzle: size does not match swizzle");
return -1;
}
if(mat->colSize != vec_size){
if(mat->colSize == 4 && vec_size != 3){
- PyErr_SetString(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same");
+ PyErr_SetString(PyExc_AttributeError,
+ "vector * matrix: matrix column size "
+ "and the vector size must be the same");
return -1;
}
else {
VectorObject *self;
if(size > 4 || size < 2) {
- PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid size");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Vector(): invalid size");
return NULL;
}
self->wrapped = Py_NEW;
}
else {
- PyErr_SetString(PyExc_RuntimeError, "Vector(): invalid type");
+ PyErr_SetString(PyExc_RuntimeError,
+ "Vector(): invalid type, internal error");
return NULL;
}
}
return NULL;
}
if(vec1->size != 3 || vec2->size != 3 || vec3->size != 3 || ray->size != 3 || ray_off->size != 3) {
- PyErr_SetString(PyExc_ValueError, "only 3D vectors for all parameters");
+ PyErr_SetString(PyExc_ValueError,
+ "only 3D vectors for all parameters");
return NULL;
}
return NULL;
}
if(vec1->size != vec2->size || vec1->size != vec3->size || vec3->size != vec2->size) {
- PyErr_SetString(PyExc_ValueError,"vectors must be of the same size");
+ PyErr_SetString(PyExc_ValueError,
+ "vectors must be of the same size");
return NULL;
}
}
}
else {
- PyErr_SetString(PyExc_ValueError, "2D/3D vectors only");
+ PyErr_SetString(PyExc_ValueError,
+ "2D/3D vectors only");
return NULL;
}
}
return NULL;
}
if(vec1->size != vec2->size || vec1->size != vec3->size) {
- PyErr_SetString(PyExc_ValueError, "vectors must be of the same size");
+ PyErr_SetString(PyExc_ValueError,
+ "vectors must be of the same size");
return NULL;
}
if(vec1->size < 3) {
- PyErr_SetString(PyExc_ValueError, "2D vectors unsupported");
+ PyErr_SetString(PyExc_ValueError,
+ "2D vectors unsupported");
return NULL;
}
return NULL;
}
if(vec1->size != vec2->size || vec1->size != vec3->size || vec1->size != vec4->size) {
- PyErr_SetString(PyExc_ValueError,"vectors must be of the same size");
+ PyErr_SetString(PyExc_ValueError,
+ "vectors must be of the same size");
return NULL;
}
if(vec1->size < 3) {
- PyErr_SetString(PyExc_ValueError, "2D vectors unsupported");
+ PyErr_SetString(PyExc_ValueError,
+ "2D vectors unsupported");
return NULL;
}
}
if(vec1->size != vec2->size || vec1->size != vec3->size) {
- PyErr_SetString(PyExc_ValueError, "vectors must be of the same size");
+ PyErr_SetString(PyExc_ValueError,
+ "vectors must be of the same size");
return NULL;
}
return PyFloat_FromDouble(area_tri_v2(vec1->vec, vec2->vec, vec3->vec));
}
else {
- PyErr_SetString(PyExc_ValueError, "only 2D,3D vectors are supported");
+ PyErr_SetString(PyExc_ValueError,
+ "only 2D,3D vectors are supported");
return NULL;
}
}
int index, *dl_face, totpoints=0;
if(!PySequence_Check(polyLineSeq)) {
- PyErr_SetString(PyExc_TypeError, "expected a sequence of poly lines");
+ PyErr_SetString(PyExc_TypeError,
+ "expected a sequence of poly lines");
return NULL;
}
if (!PySequence_Check(polyLine)) {
freedisplist(&dispbase);
Py_XDECREF(polyLine); /* may be null so use Py_XDECREF*/
- PyErr_SetString(PyExc_TypeError, "One or more of the polylines is not a sequence of mathutils.Vector's");
+ PyErr_SetString(PyExc_TypeError,
+ "One or more of the polylines is not a sequence of mathutils.Vector's");
return NULL;
}
if (EXPP_check_sequence_consistency(polyLine, &vector_Type) != 1) {
freedisplist(&dispbase);
Py_DECREF(polyLine);
- PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type");
+ PyErr_SetString(PyExc_TypeError,
+ "A point in one of the polylines is not a mathutils.Vector type");
return NULL;
}
#endif
if(ls_error) {
freedisplist(&dispbase); /* possible some dl was allocated */
- PyErr_SetString(PyExc_TypeError, "A point in one of the polylines is not a mathutils.Vector type");
+ PyErr_SetString(PyExc_TypeError,
+ "A point in one of the polylines "
+ "is not a mathutils.Vector type");
return NULL;
}
else if (totpoints) {
tri_list= PyList_New(dl->parts);
if(!tri_list) {
freedisplist(&dispbase);
- PyErr_SetString(PyExc_RuntimeError, "geometry.PolyFill failed to make a new list");
+ PyErr_SetString(PyExc_RuntimeError,
+ "failed to make a new list");
return NULL;
}
}
if(ELEM4(2, line_a->size, line_b->size, plane_co->size, plane_no->size)) {
- PyErr_SetString(PyExc_RuntimeError, "geometry.intersect_line_plane(...) can't use 2D Vectors");
+ PyErr_SetString(PyExc_RuntimeError,
+ "geometry.intersect_line_plane(...): "
+ " can't use 2D Vectors");
return NULL;
}
}
if(ELEM3(2, line_a->size, line_b->size, sphere_co->size)) {
- PyErr_SetString(PyExc_RuntimeError, "geometry.intersect_line_sphere(...) can't use 2D Vectors");
+ PyErr_SetString(PyExc_RuntimeError,
+ "geometry.intersect_line_sphere(...): "
+ " can't use 2D Vectors");
return NULL;
}
else {
/* Error checking must already be done */
if(!PyList_Check(value)) {
- PyErr_SetString(PyExc_TypeError, "can only back a list of [x, y, w, h]");
+ PyErr_SetString(PyExc_TypeError,
+ "can only back a list of [x, y, w, h]");
return -1;
}
list_item= PyList_GET_ITEM(value, i);
if(!PyList_Check(list_item) || PyList_Size(list_item) < 4) {
MEM_freeN(*boxarray);
- PyErr_SetString(PyExc_TypeError, "can only pack a list of [x, y, w, h]");
+ PyErr_SetString(PyExc_TypeError,
+ "can only pack a list of [x, y, w, h]");
return -1;
}
if (box->w < 0.0f || box->h < 0.0f) {
MEM_freeN(*boxarray);
- PyErr_SetString(PyExc_TypeError, "error parsing width and height values from list: [x, y, w, h], not numbers or below zero");
+ PyErr_SetString(PyExc_TypeError,
+ "error parsing width and height values from list: "
+ "[x, y, w, h], not numbers or below zero");
return -1;
}
PyObject *ret;
if(!PyList_Check(boxlist)) {
- PyErr_SetString(PyExc_TypeError, "expected a list of boxes [[x, y, w, h], ... ]");
+ PyErr_SetString(PyExc_TypeError,
+ "expected a list of boxes [[x, y, w, h], ... ]");
return NULL;
}
}
if(resolu <= 1) {
- PyErr_SetString(PyExc_ValueError, "resolution must be 2 or over");
+ PyErr_SetString(PyExc_ValueError,
+ "resolution must be 2 or over");
return NULL;
}
vec_t2_tar->size != 3 ||
vec_t3_tar->size != 3)
{
- PyErr_SetString(PyExc_ValueError, "One of more of the vector arguments wasnt a 3D vector");
+ PyErr_SetString(PyExc_ValueError,
+ "One of more of the vector arguments wasnt a 3D vector");
return NULL;
}
projects / blender.git / commitdiff