python mathutils change

 quat * quat was returning the dot product (a float), rather then the cross product.
 Use BLI_math's mul_qt_qtqt() function.

6 files changed, 27 insertions, 81 deletions

diff --git a/source/blender/blenlib/BLI_math_rotation.h b/source/blender/blenlib/BLI_math_rotation.h
index f3da20f91c2..ac8ed041ebc 100644
--- a/source/blender/blenlib/BLI_math_rotation.h
+++ b/source/blender/blenlib/BLI_math_rotation.h
@@ -44,9 +44,9 @@ void copy_qt_qt(float q[4], const float a[4]);
 
 /* arithmetic */
 void mul_qt_qtqt(float q[4], const float a[4], const float b[4]);
-void mul_qt_v3(float q[4], float r[3]);
-void mul_qt_fl(float q[4], float f);
-void mul_fac_qt_fl(float q[4], float f);
+void mul_qt_v3(const float q[4], float r[3]);
+void mul_qt_fl(float q[4], const float f);
+void mul_fac_qt_fl(float q[4], const float f);
 
 void sub_qt_qtqt(float q[4], float a[4], float b[4]);
 
diff --git a/source/blender/blenlib/intern/math_rotation.c b/source/blender/blenlib/intern/math_rotation.c
index a8cacb60f05..4d015e527a8 100644
--- a/source/blender/blenlib/intern/math_rotation.c
+++ b/source/blender/blenlib/intern/math_rotation.c
@@ -63,7 +63,7 @@ void mul_qt_qtqt(float *q, const float *q1, const float *q2)
 }
 
 /* Assumes a unit quaternion */
-void mul_qt_v3(float *q, float *v)
+void mul_qt_v3(const float *q, float *v)
 {
 	float t0, t1, t2;
 
@@ -111,7 +111,7 @@ void invert_qt_qt(float *q1, const float *q2)
 }
 
 /* simple mult */
-void mul_qt_fl(float *q, float f)
+void mul_qt_fl(float *q, const float f)
 {
 	q[0] *= f;
 	q[1] *= f;
@@ -127,7 +127,7 @@ void sub_qt_qtqt(float *q, float *q1, float *q2)
 }
 
 /* angular mult factor */
-void mul_fac_qt_fl(float *q, float fac)
+void mul_fac_qt_fl(float *q, const float fac)
 {
 	float angle= fac*saacos(q[0]);	/* quat[0]= cos(0.5*angle), but now the 0.5 and 2.0 rule out */
 	
diff --git a/source/blender/python/generic/mathutils.c b/source/blender/python/generic/mathutils.c
index f953e7c6e4f..a38ec7ce688 100644
--- a/source/blender/python/generic/mathutils.c
+++ b/source/blender/python/generic/mathutils.c
@@ -44,6 +44,7 @@
  * - toEuler --> to_euler
  * - toQuat --> to_quat
  * - Vector.toTrackQuat --> Vector.to_track_quat
+ * - Quaternion * Quaternion --> cross product (not dot product)
  *
  * Moved to Geometry module: Intersect, TriangleArea, TriangleNormal, QuadNormal, LineIntersect
  */
@@ -92,74 +93,6 @@ int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *
 	return size;
 }
 
-//-----------------------------METHODS----------------------------
-//-----------------quat_rotation (internal)-----------
-//This function multiplies a vector/point * quat or vice versa
-//to rotate the point/vector by the quaternion
-//arguments should all be 3D
-PyObject *quat_rotation(PyObject *arg1, PyObject *arg2)
-{
-	float rot[3];
-	QuaternionObject *quat = NULL;
-	VectorObject *vec = NULL;
-
-	if(QuaternionObject_Check(arg1)){
-		quat = (QuaternionObject*)arg1;
-		if(!BaseMath_ReadCallback(quat))
-			return NULL;
-
-		if(VectorObject_Check(arg2)){
-			vec = (VectorObject*)arg2;
-			
-			if(!BaseMath_ReadCallback(vec))
-				return NULL;
-			
-			rot[0] = quat->quat[0]*quat->quat[0]*vec->vec[0] + 2*quat->quat[2]*quat->quat[0]*vec->vec[2] - 
-				2*quat->quat[3]*quat->quat[0]*vec->vec[1] + quat->quat[1]*quat->quat[1]*vec->vec[0] + 
-				2*quat->quat[2]*quat->quat[1]*vec->vec[1] + 2*quat->quat[3]*quat->quat[1]*vec->vec[2] - 
-				quat->quat[3]*quat->quat[3]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[0];
-			rot[1] = 2*quat->quat[1]*quat->quat[2]*vec->vec[0] + quat->quat[2]*quat->quat[2]*vec->vec[1] + 
-				2*quat->quat[3]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[3]*vec->vec[0] - 
-				quat->quat[3]*quat->quat[3]*vec->vec[1] + quat->quat[0]*quat->quat[0]*vec->vec[1] - 
-				2*quat->quat[1]*quat->quat[0]*vec->vec[2] - quat->quat[1]*quat->quat[1]*vec->vec[1];
-			rot[2] = 2*quat->quat[1]*quat->quat[3]*vec->vec[0] + 2*quat->quat[2]*quat->quat[3]*vec->vec[1] + 
-				quat->quat[3]*quat->quat[3]*vec->vec[2] - 2*quat->quat[0]*quat->quat[2]*vec->vec[0] - 
-				quat->quat[2]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[1]*vec->vec[1] - 
-				quat->quat[1]*quat->quat[1]*vec->vec[2] + quat->quat[0]*quat->quat[0]*vec->vec[2];
-			return newVectorObject(rot, 3, Py_NEW, NULL);
-		}
-	}else if(VectorObject_Check(arg1)){
-		vec = (VectorObject*)arg1;
-		
-		if(!BaseMath_ReadCallback(vec))
-			return NULL;
-		
-		if(QuaternionObject_Check(arg2)){
-			quat = (QuaternionObject*)arg2;
-			if(!BaseMath_ReadCallback(quat))
-				return NULL;
-
-			rot[0] = quat->quat[0]*quat->quat[0]*vec->vec[0] + 2*quat->quat[2]*quat->quat[0]*vec->vec[2] - 
-				2*quat->quat[3]*quat->quat[0]*vec->vec[1] + quat->quat[1]*quat->quat[1]*vec->vec[0] + 
-				2*quat->quat[2]*quat->quat[1]*vec->vec[1] + 2*quat->quat[3]*quat->quat[1]*vec->vec[2] - 
-				quat->quat[3]*quat->quat[3]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[0];
-			rot[1] = 2*quat->quat[1]*quat->quat[2]*vec->vec[0] + quat->quat[2]*quat->quat[2]*vec->vec[1] + 
-				2*quat->quat[3]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[3]*vec->vec[0] - 
-				quat->quat[3]*quat->quat[3]*vec->vec[1] + quat->quat[0]*quat->quat[0]*vec->vec[1] - 
-				2*quat->quat[1]*quat->quat[0]*vec->vec[2] - quat->quat[1]*quat->quat[1]*vec->vec[1];
-			rot[2] = 2*quat->quat[1]*quat->quat[3]*vec->vec[0] + 2*quat->quat[2]*quat->quat[3]*vec->vec[1] + 
-				quat->quat[3]*quat->quat[3]*vec->vec[2] - 2*quat->quat[0]*quat->quat[2]*vec->vec[0] - 
-				quat->quat[2]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[1]*vec->vec[1] - 
-				quat->quat[1]*quat->quat[1]*vec->vec[2] + quat->quat[0]*quat->quat[0]*vec->vec[2];
-			return newVectorObject(rot, 3, Py_NEW, NULL);
-		}
-	}
-
-	PyErr_SetString(PyExc_RuntimeError, "quat_rotation(internal): internal problem rotating vector/point\n");
-	return NULL;
-	
-}
-
 //----------------------------------MATRIX FUNCTIONS--------------------
 //----------------------------------mathutils.RotationMatrix() ----------
 //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
diff --git a/source/blender/python/generic/mathutils.h b/source/blender/python/generic/mathutils.h
index 7b83d35ff1e..85fbe3225ba 100644
--- a/source/blender/python/generic/mathutils.h
+++ b/source/blender/python/generic/mathutils.h
@@ -63,8 +63,6 @@ void BaseMathObject_dealloc(BaseMathObject * self);
 PyObject *Mathutils_Init(void);
 PyObject *Noise_Init(void); /* lazy, saves having own header */
 
-PyObject *quat_rotation(PyObject *arg1, PyObject *arg2);
-
 int EXPP_FloatsAreEqual(float A, float B, int floatSteps);
 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps);
 
diff --git a/source/blender/python/generic/mathutils_quat.c b/source/blender/python/generic/mathutils_quat.c
index 480b724111d..6cd2d0ec727 100644
--- a/source/blender/python/generic/mathutils_quat.c
+++ b/source/blender/python/generic/mathutils_quat.c
@@ -660,8 +660,9 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
 			return NULL;
 	}
 
-	if(quat1 && quat2) { /* QUAT*QUAT (dot product) */
-		return PyFloat_FromDouble(dot_qtqt(quat1->quat, quat2->quat));
+	if(quat1 && quat2) { /* QUAT*QUAT (cross product) */
+		mul_qt_qtqt(quat, quat1->quat, quat2->quat);
+		return newQuaternionObject(quat, Py_NEW, NULL);
 	}
 	
 	/* the only case this can happen (for a supported type is "FLOAT*QUAT" ) */
@@ -677,12 +678,19 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
 	}
 	else { /* QUAT*SOMETHING */
 		if(VectorObject_Check(q2)){  /* QUAT*VEC */
+			float tvec[3];
 			vec = (VectorObject*)q2;
 			if(vec->size != 3){
 				PyErr_SetString(PyExc_TypeError, "Quaternion multiplication: only 3D vector rotations currently supported\n");
 				return NULL;
 			}
-			return quat_rotation((PyObject*)quat1, (PyObject*)vec); /* vector updating done inside the func */
+			if(!BaseMath_ReadCallback(vec)) {
+				return NULL;
+			}
+
+			copy_v3_v3(tvec, vec->vec);
+			mul_qt_v3(quat1->quat, tvec);
+			return newVectorObject(tvec, 3, Py_NEW, NULL);
 		}
 		
 		scalar= PyFloat_AsDouble(q2);
diff --git a/source/blender/python/generic/mathutils_vector.c b/source/blender/python/generic/mathutils_vector.c
index eab03fc5911..5c8401ca15a 100644
--- a/source/blender/python/generic/mathutils_vector.c
+++ b/source/blender/python/generic/mathutils_vector.c
@@ -1010,13 +1010,20 @@ static PyObject *Vector_mul(PyObject * v1, PyObject * v2)
 		/* VEC * MATRIX */
 		return row_vector_multiplication(vec1, (MatrixObject*)v2);
 	} else if (QuaternionObject_Check(v2)) {
-		QuaternionObject *quat = (QuaternionObject*)v2; /* quat_rotation validates */
+		/* VEC * QUAT */
+		QuaternionObject *quat2 = (QuaternionObject*)v2;
+		float tvec[4];
 
 		if(vec1->size != 3) {
 			PyErr_SetString(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported\n");
 			return NULL;
 		}
-		return quat_rotation((PyObject*)vec1, (PyObject*)quat);
+		if(!BaseMath_ReadCallback(quat2)) {
+			return NULL;
+		}
+		copy_v3_v3(tvec, vec1->vec);
+		mul_qt_v3(quat2->quat, tvec);
+		return newVectorObject(tvec, 3, Py_NEW, NULL);
 	}
 	else if (((scalar= PyFloat_AsDouble(v2)) == -1.0 && PyErr_Occurred())==0) { /* VEC*FLOAT */
 		int i;