forked from bartvdbraak/blender
many mathutils exception types were wrong, went over all exceptions in mathutils and double checked the're correct.
This commit is contained in:
parent
f70f167237
commit
b028cba0e4
@ -75,7 +75,7 @@ static int mathutils_array_parse_fast(float *array, int array_min, int array_max
|
||||
do {
|
||||
i--;
|
||||
if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) && PyErr_Occurred()) {
|
||||
PyErr_Format(PyExc_ValueError,
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"%.200s: sequence index %d expected a number, "
|
||||
"found '%.200s' type, ",
|
||||
error_prefix, i, Py_TYPE(item)->tp_name);
|
||||
|
@ -259,7 +259,7 @@ static int Color_ass_slice(ColorObject *self, int begin, int end, PyObject *seq)
|
||||
return -1;
|
||||
|
||||
if(size != (end - begin)){
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"color[begin:end] = []: "
|
||||
"size mismatch in slice assignment");
|
||||
return -1;
|
||||
@ -296,7 +296,7 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item)
|
||||
return Color_slice(self, start, stop);
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with color");
|
||||
return NULL;
|
||||
}
|
||||
@ -328,7 +328,7 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu
|
||||
if (step == 1)
|
||||
return Color_ass_slice(self, start, stop, value);
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with color");
|
||||
return -1;
|
||||
}
|
||||
@ -371,7 +371,7 @@ static PyObject *Color_add(PyObject *v1, PyObject *v2)
|
||||
float col[COLOR_SIZE];
|
||||
|
||||
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Color addition: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -393,7 +393,7 @@ static PyObject *Color_iadd(PyObject *v1, PyObject *v2)
|
||||
ColorObject *color1 = NULL, *color2 = NULL;
|
||||
|
||||
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Color addition: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -418,7 +418,7 @@ static PyObject *Color_sub(PyObject *v1, PyObject *v2)
|
||||
float col[COLOR_SIZE];
|
||||
|
||||
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Color subtraction: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -440,7 +440,7 @@ static PyObject *Color_isub(PyObject *v1, PyObject *v2)
|
||||
ColorObject *color1= NULL, *color2= NULL;
|
||||
|
||||
if (!ColorObject_Check(v1) || !ColorObject_Check(v2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Color subtraction: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -555,7 +555,9 @@ static PyObject *Color_imul(PyObject *v1, PyObject *v2)
|
||||
mul_vn_fl(color->col, COLOR_SIZE, 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;
|
||||
}
|
||||
|
||||
@ -846,9 +848,7 @@ PyObject *newColorObject(float *col, int type, PyTypeObject *base_type)
|
||||
self->wrapped = Py_NEW;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"Color(): invalid type, internal error");
|
||||
return NULL;
|
||||
Py_FatalError("Color(): invalid type!");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -99,7 +99,7 @@ short euler_order_from_string(const char *str, const char *error_prefix)
|
||||
}
|
||||
}
|
||||
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
PyErr_Format(PyExc_ValueError,
|
||||
"%s: invalid euler order '%s'",
|
||||
error_prefix, str);
|
||||
return -1;
|
||||
@ -209,7 +209,7 @@ static PyObject *Euler_rotate_axis(EulerObject * self, PyObject *args)
|
||||
return NULL;
|
||||
}
|
||||
if(!(ELEM3(*axis, 'X', 'Y', 'Z') && axis[1]=='\0')){
|
||||
PyErr_SetString(PyExc_TypeError, "euler.rotate(): "
|
||||
PyErr_SetString(PyExc_ValueError, "euler.rotate(): "
|
||||
"expected axis to be 'X', 'Y' or 'Z'");
|
||||
return NULL;
|
||||
}
|
||||
@ -449,7 +449,7 @@ static int Euler_ass_slice(EulerObject *self, int begin, int end, PyObject *seq)
|
||||
return -1;
|
||||
|
||||
if(size != (end - begin)){
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"euler[begin:end] = []: "
|
||||
"size mismatch in slice assignment");
|
||||
return -1;
|
||||
@ -486,7 +486,7 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
|
||||
return Euler_slice(self, start, stop);
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with eulers");
|
||||
return NULL;
|
||||
}
|
||||
@ -519,7 +519,7 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu
|
||||
if (step == 1)
|
||||
return Euler_ass_slice(self, start, stop, value);
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with euler");
|
||||
return -1;
|
||||
}
|
||||
@ -701,9 +701,7 @@ PyObject *newEulerObject(float *eul, short order, int type, PyTypeObject *base_t
|
||||
self->wrapped = Py_NEW;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"Euler(): invalid type, internal error");
|
||||
return NULL;
|
||||
Py_FatalError("Euler(): invalid type!");
|
||||
}
|
||||
|
||||
self->order= order;
|
||||
|
@ -225,7 +225,7 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
|
||||
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,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.RotationMatrix(): "
|
||||
"3rd argument axis value must be a 3D vector "
|
||||
"or a string in 'X', 'Y', 'Z'");
|
||||
@ -240,19 +240,19 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
|
||||
angle= angle_wrap_rad(angle);
|
||||
|
||||
if(matSize != 2 && matSize != 3 && matSize != 4) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.RotationMatrix(): "
|
||||
"can only return a 2x2 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
}
|
||||
if(matSize == 2 && (vec != NULL)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"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,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.RotationMatrix(): "
|
||||
"axis of rotation for 3d and 4d matrices is required");
|
||||
return NULL;
|
||||
@ -300,7 +300,7 @@ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
|
||||
}
|
||||
else {
|
||||
/* should never get here */
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.RotationMatrix(): unknown error");
|
||||
return NULL;
|
||||
}
|
||||
@ -365,7 +365,7 @@ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
|
||||
return NULL;
|
||||
}
|
||||
if(matSize != 2 && matSize != 3 && matSize != 4) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Matrix.Scale(): "
|
||||
"can only return a 2x2 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
@ -451,7 +451,7 @@ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
|
||||
return NULL;
|
||||
}
|
||||
if(matSize != 2 && matSize != 3 && matSize != 4) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.Matrix.OrthoProjection(): "
|
||||
"can only return a 2x2 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
@ -568,7 +568,7 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
|
||||
return NULL;
|
||||
}
|
||||
if(matSize != 2 && matSize != 3 && matSize != 4) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.Matrix.Shear(): "
|
||||
"can only return a 2x2 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
@ -578,7 +578,7 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
|
||||
float const factor= PyFloat_AsDouble(fac);
|
||||
|
||||
if(factor==-1.0f && PyErr_Occurred()) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"mathutils.Matrix.Shear(): "
|
||||
"the factor to be a float");
|
||||
return NULL;
|
||||
@ -595,7 +595,7 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
|
||||
mat[1] = factor;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Matrix.Shear(): "
|
||||
"expected: X, Y or wrong matrix size for shearing plane");
|
||||
return NULL;
|
||||
@ -627,7 +627,7 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
|
||||
mat[2] = factor[1];
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"mathutils.Matrix.Shear(): "
|
||||
"expected: X, Y, XY, XZ, YZ");
|
||||
return NULL;
|
||||
@ -686,7 +686,7 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
|
||||
|
||||
/*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,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"matrix.to_quat(): "
|
||||
"inappropriate matrix size - expects 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
@ -750,7 +750,7 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
|
||||
mat= tmat;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"matrix.to_euler(): "
|
||||
"inappropriate matrix size - expects 3x3 or 4x4 matrix");
|
||||
return NULL;
|
||||
@ -879,7 +879,7 @@ static PyObject *Matrix_to_3x3(MatrixObject *self)
|
||||
return NULL;
|
||||
|
||||
if((self->col_size < 3) || (self->row_size < 3)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.to_3x3(): inappropriate matrix size");
|
||||
return NULL;
|
||||
}
|
||||
@ -903,7 +903,7 @@ static PyObject *Matrix_to_translation(MatrixObject *self)
|
||||
return NULL;
|
||||
|
||||
if((self->col_size < 3) || self->row_size < 4){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.to_translation(): "
|
||||
"inappropriate matrix size");
|
||||
return NULL;
|
||||
@ -933,7 +933,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
|
||||
|
||||
/*must be 3-4 cols, 3-4 rows, square matrix*/
|
||||
if((self->col_size < 3) || (self->row_size < 3)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.to_scale(): "
|
||||
"inappropriate matrix size, 3x3 minimum size");
|
||||
return NULL;
|
||||
@ -969,7 +969,7 @@ static PyObject *Matrix_invert(MatrixObject *self)
|
||||
return NULL;
|
||||
|
||||
if(self->row_size != self->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.invert(ed): "
|
||||
"only square matrices are supported");
|
||||
return NULL;
|
||||
@ -1050,7 +1050,7 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value)
|
||||
return NULL;
|
||||
|
||||
if(self->col_size != 3 || self->row_size != 3) {
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Matrix must have 3x3 dimensions");
|
||||
return NULL;
|
||||
}
|
||||
@ -1082,7 +1082,7 @@ static PyObject *Matrix_decompose(MatrixObject *self)
|
||||
float size[3];
|
||||
|
||||
if(self->col_size != 4 || self->row_size != 4) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.decompose(): "
|
||||
"inappropriate matrix size - expects 4x4 matrix");
|
||||
return NULL;
|
||||
@ -1125,7 +1125,7 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
|
||||
return NULL;
|
||||
|
||||
if(self->row_size != mat2->row_size || self->col_size != mat2->col_size) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"matrix.lerp(): "
|
||||
"expects both matrix objects of the same dimensions");
|
||||
return NULL;
|
||||
@ -1142,7 +1142,7 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
|
||||
blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->contigPtr, (float (*)[3])mat2->contigPtr, fac);
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"matrix.lerp(): "
|
||||
"only 3x3 and 4x4 matrices supported");
|
||||
return NULL;
|
||||
@ -1168,7 +1168,7 @@ static PyObject *Matrix_determinant(MatrixObject *self)
|
||||
return NULL;
|
||||
|
||||
if(self->row_size != self->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.determinant: "
|
||||
"only square matrices are supported");
|
||||
return NULL;
|
||||
@ -1192,7 +1192,7 @@ static PyObject *Matrix_transpose(MatrixObject *self)
|
||||
return NULL;
|
||||
|
||||
if(self->row_size != self->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.transpose(d): "
|
||||
"only square matrices are supported");
|
||||
return NULL;
|
||||
@ -1261,7 +1261,7 @@ static PyObject *Matrix_identity(MatrixObject *self)
|
||||
return NULL;
|
||||
|
||||
if(self->row_size != self->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix.identity: "
|
||||
"only square matrices are supported");
|
||||
return NULL;
|
||||
@ -1409,7 +1409,7 @@ static int Matrix_ass_item(MatrixObject *self, int i, PyObject *value)
|
||||
return -1;
|
||||
|
||||
if(i >= self->row_size || i < 0){
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"matrix[attribute] = x: bad column");
|
||||
return -1;
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
|
||||
|
||||
if(PySequence_Fast_GET_SIZE(value_fast) != size) {
|
||||
Py_DECREF(value_fast);
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"matrix[begin:end] = []: "
|
||||
"size mismatch in slice assignment");
|
||||
return -1;
|
||||
@ -1509,7 +1509,7 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
|
||||
mat2 = (MatrixObject*)m2;
|
||||
|
||||
if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Matrix addition: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -1519,7 +1519,7 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
|
||||
return NULL;
|
||||
|
||||
if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Matrix addition: "
|
||||
"matrices must have the same dimensions for this operation");
|
||||
return NULL;
|
||||
@ -1540,7 +1540,7 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
|
||||
mat2 = (MatrixObject*)m2;
|
||||
|
||||
if(!MatrixObject_Check(m1) || !MatrixObject_Check(m2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Matrix addition: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -1550,7 +1550,7 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
|
||||
return NULL;
|
||||
|
||||
if(mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Matrix addition: "
|
||||
"matrices must have the same dimensions for this operation");
|
||||
return NULL;
|
||||
@ -1589,7 +1589,7 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
|
||||
if(mat1 && mat2) {
|
||||
/*MATRIX * MATRIX*/
|
||||
if(mat1->row_size != mat2->col_size){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Matrix multiplication: "
|
||||
"matrix A rowsize must equal matrix B colsize");
|
||||
return NULL;
|
||||
@ -1683,14 +1683,14 @@ static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item)
|
||||
return Matrix_slice(self, start, stop);
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with matricies");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"vector indices must be integers, not %.200s",
|
||||
"matrix indices must be integers, not %.200s",
|
||||
Py_TYPE(item)->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
@ -1715,7 +1715,7 @@ static int Matrix_ass_subscript(MatrixObject* self, PyObject* item, PyObject* va
|
||||
if (step == 1)
|
||||
return Matrix_ass_slice(self, start, stop, value);
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with matricies");
|
||||
return -1;
|
||||
}
|
||||
@ -2021,8 +2021,7 @@ PyObject *newMatrixObject(float *mat, const unsigned short rowSize, const unsign
|
||||
self->wrapped = Py_NEW;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"Matrix(): invalid type, internal error");
|
||||
Py_FatalError("Matrix(): invalid type!");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
@ -248,7 +248,7 @@ static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args)
|
||||
return NULL;
|
||||
|
||||
if(fac > 1.0f || fac < 0.0f) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"quat.slerp(): "
|
||||
"interpolation factor must be between 0.0 and 1.0");
|
||||
return NULL;
|
||||
@ -582,7 +582,7 @@ static int Quaternion_ass_slice(QuaternionObject *self, int begin, int end, PyOb
|
||||
return -1;
|
||||
|
||||
if(size != (end - begin)){
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"quaternion[begin:end] = []: "
|
||||
"size mismatch in slice assignment");
|
||||
return -1;
|
||||
@ -620,7 +620,7 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item)
|
||||
return Quaternion_slice(self, start, stop);
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with quaternions");
|
||||
return NULL;
|
||||
}
|
||||
@ -653,7 +653,7 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb
|
||||
if (step == 1)
|
||||
return Quaternion_ass_slice(self, start, stop, value);
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with quaternion");
|
||||
return -1;
|
||||
}
|
||||
@ -675,7 +675,7 @@ static PyObject *Quaternion_add(PyObject *q1, PyObject *q2)
|
||||
QuaternionObject *quat1 = NULL, *quat2 = NULL;
|
||||
|
||||
if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Quaternion addition: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -698,7 +698,7 @@ static PyObject *Quaternion_sub(PyObject *q1, PyObject *q2)
|
||||
QuaternionObject *quat1 = NULL, *quat2 = NULL;
|
||||
|
||||
if(!QuaternionObject_Check(q1) || !QuaternionObject_Check(q2)) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"Quaternion addition: "
|
||||
"arguments not valid for this operation");
|
||||
return NULL;
|
||||
@ -1142,9 +1142,7 @@ PyObject *newQuaternionObject(float *quat, int type, PyTypeObject *base_type)
|
||||
self->wrapped = Py_NEW;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"Quaternion(): invalid type, internal error");
|
||||
return NULL;
|
||||
Py_FatalError("Quaternion(): invalid type!");
|
||||
}
|
||||
}
|
||||
return (PyObject *) self;
|
||||
|
@ -442,8 +442,7 @@ static PyObject *Vector_to_track_quat(VectorObject *self, PyObject *args)
|
||||
}
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
axis_err_msg);
|
||||
PyErr_SetString(PyExc_ValueError, axis_err_msg);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
@ -667,7 +666,7 @@ static PyObject *Vector_rotation_difference(VectorObject *self, PyObject *value)
|
||||
float quat[4], vec_a[3], vec_b[3];
|
||||
|
||||
if(self->size < 3) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"vec.difference(value): "
|
||||
"expects both vectors to be size 3 or 4");
|
||||
return NULL;
|
||||
@ -1094,7 +1093,7 @@ static int column_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject
|
||||
vec_cpy[3] = 1.0f;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
"matrix * vector: "
|
||||
"matrix.row_size and len(vector) must be the same, "
|
||||
"except for 3D vector * 4x4 matrix.");
|
||||
@ -1147,7 +1146,7 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
|
||||
double dot = 0.0f;
|
||||
|
||||
if(vec1->size != vec2->size) {
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Vector multiplication: "
|
||||
"vectors must have the same dimensions for this operation");
|
||||
return NULL;
|
||||
@ -1177,7 +1176,7 @@ static PyObject *Vector_mul(PyObject *v1, PyObject *v2)
|
||||
float tvec[3];
|
||||
|
||||
if(vec1->size != 3) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Vector multiplication: "
|
||||
"only 3D vector rotations (with quats) currently supported");
|
||||
return NULL;
|
||||
@ -1235,7 +1234,7 @@ static PyObject *Vector_imul(PyObject *v1, PyObject *v2)
|
||||
QuaternionObject *quat2 = (QuaternionObject*)v2;
|
||||
|
||||
if(vec->size != 3) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"Vector multiplication: "
|
||||
"only 3D vector rotations (with quats) currently supported");
|
||||
return NULL;
|
||||
@ -1485,7 +1484,7 @@ static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
|
||||
return Vector_slice(self, start, stop);
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with vectors");
|
||||
return NULL;
|
||||
}
|
||||
@ -1517,7 +1516,7 @@ static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* va
|
||||
if (step == 1)
|
||||
return Vector_ass_slice(self, start, stop, value);
|
||||
else {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"slice steps not supported with vectors");
|
||||
return -1;
|
||||
}
|
||||
@ -1620,7 +1619,7 @@ static int Vector_setLength(VectorObject *self, PyObject *value)
|
||||
}
|
||||
|
||||
if (param < 0.0) {
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"cannot set a vectors length to a negative value");
|
||||
return -1;
|
||||
}
|
||||
@ -2174,7 +2173,7 @@ static int row_vector_multiplication(float rvec[4], VectorObject* vec, MatrixObj
|
||||
|
||||
if(mat->colSize != vec_size){
|
||||
if(mat->colSize == 4 && vec_size != 3){
|
||||
PyErr_SetString(PyExc_AttributeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"vector * matrix: matrix column size "
|
||||
"and the vector size must be the same");
|
||||
return -1;
|
||||
@ -2390,9 +2389,7 @@ PyObject *newVectorObject(float *vec, const int size, const int type, PyTypeObje
|
||||
self->wrapped = Py_NEW;
|
||||
}
|
||||
else {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
"Vector(): invalid type, internal error");
|
||||
return NULL;
|
||||
Py_FatalError("Vector(): invalid type!");
|
||||
}
|
||||
}
|
||||
return (PyObject *) self;
|
||||
|
@ -556,7 +556,7 @@ static PyObject *M_Geometry_intersect_line_plane(PyObject *UNUSED(self), PyObjec
|
||||
}
|
||||
|
||||
if(ELEM4(2, line_a->size, line_b->size, plane_co->size, plane_no->size)) {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"geometry.intersect_line_plane(...): "
|
||||
" can't use 2D Vectors");
|
||||
return NULL;
|
||||
@ -614,7 +614,7 @@ static PyObject *M_Geometry_intersect_line_sphere(PyObject *UNUSED(self), PyObje
|
||||
}
|
||||
|
||||
if(ELEM3(2, line_a->size, line_b->size, sphere_co->size)) {
|
||||
PyErr_SetString(PyExc_RuntimeError,
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"geometry.intersect_line_sphere(...): "
|
||||
" can't use 2D Vectors");
|
||||
return NULL;
|
||||
@ -881,6 +881,7 @@ static int boxPack_FromPyObject(PyObject *value, boxPack **boxarray)
|
||||
box->h= (float)PyFloat_AsDouble(item_2);
|
||||
box->index= i;
|
||||
|
||||
/* accounts for error case too and overwrites with own error */
|
||||
if (box->w < 0.0f || box->h < 0.0f) {
|
||||
MEM_freeN(*boxarray);
|
||||
PyErr_SetString(PyExc_TypeError,
|
||||
@ -1075,7 +1076,7 @@ static PyObject *M_Geometry_barycentric_transform(PyObject *UNUSED(self), PyObje
|
||||
vec_t3_tar->size != 3)
|
||||
{
|
||||
PyErr_SetString(PyExc_ValueError,
|
||||
"One of more of the vector arguments wasnt a 3D vector");
|
||||
"One of more of the vector arguments wasn't a 3D vector");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user