== Constraints System ==
[blender-staging.git] / source / blender / blenlib / intern / arithb.c
index 67d3b61e93e5a75e19c0d431c583d97c1cf0ecdf..125c24a7ada418525a0ebffa496e080ae7a5fa08 100644 (file)
@@ -4,9 +4,6 @@
  *
  * sort of cleaned up mar-01 nzc
  *
- * Functions here get counterparts with MTC prefixes. Basically, we phase
- * out the calls here in favour of fully prototyped versions.
- *
  * $Id$
  *
  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
@@ -763,7 +760,28 @@ void Mat4MulSerie(float answ[][4], float m1[][4],
        }
 }
 
+void Mat4BlendMat4(float out[][4], float dst[][4], float src[][4], float srcweight)
+{
+       float squat[4], dquat[4], fquat[4];
+       float ssize[3], dsize[3], fsize[4];
+       float sloc[3], dloc[3], floc[3];
+       
+       Mat4ToQuat(dst, dquat);
+       Mat4ToSize(dst, dsize);
+       VecCopyf(dloc, dst[3]);
+
+       Mat4ToQuat(src, squat);
+       Mat4ToSize(src, ssize);
+       VecCopyf(sloc, src[3]);
+       
+       /* do blending */
+       VecLerpf(floc, dloc, sloc, srcweight);
+       QuatInterpol(fquat, dquat, squat, srcweight);
+       VecLerpf(fsize, dsize, ssize, srcweight);
 
+       /* compose new matrix */
+       LocQuatSizeToMat4(out, floc, fquat, fsize);
+}
 
 void Mat4Clr(float *m)
 {
@@ -1770,7 +1788,6 @@ void Mat4Ortho(float mat[][4])
 
 void VecCopyf(float *v1, float *v2)
 {
-
        v1[0]= v2[0];
        v1[1]= v2[1];
        v1[2]= v2[2];
@@ -2394,6 +2411,15 @@ void VecRotToMat3( float *vec, float phi, float mat[][3])
        
 }
 
+void VecRotToMat4( float *vec, float phi, float mat[][4])
+{
+       float tmat[3][3];
+       
+       VecRotToMat3(vec, phi, tmat);
+       Mat4One(mat);
+       Mat4CpyMat3(mat, tmat);
+}
+
 void VecRotToQuat( float *vec, float phi, float *quat)
 {
        /* rotation of phi radials around vec */
@@ -2402,7 +2428,7 @@ void VecRotToQuat( float *vec, float phi, float *quat)
        quat[1]= vec[0];
        quat[2]= vec[1];
        quat[3]= vec[2];
-                                                                                                          
+       
        if( Normalize(quat+1) == 0.0) {
                QuatOne(quat);
        }
@@ -2580,6 +2606,15 @@ void SizeToMat3( float *size, float mat[][3])
        mat[2][0]= 0.0;
 }
 
+void SizeToMat4( float *size, float mat[][4])
+{
+       float tmat[3][3];
+       
+       SizeToMat3(size, tmat);
+       Mat4One(mat);
+       Mat4CpyMat3(mat, tmat);
+}
+
 void Mat3ToSize( float mat[][3], float *size)
 {
        float vec[3];
@@ -3252,43 +3287,47 @@ int point_in_tri_prism(float p[3], float v1[3], float v2[3], float v3[3])
 /********************************************************/
 
 /* make a 4x4 matrix out of 3 transform components */
+/* matrices are made in the order: scale * rot * loc */
 void LocEulSizeToMat4(float mat[][4], float loc[3], float eul[3], float size[3])
 {
-       float tmat[3][3];
+       float rmat[3][3], smat[3][3], tmat[3][3];
        
-       /* make base matrix */
-       EulToMat3(eul, tmat);
-
-       /* make new matrix */
+       /* initialise new matrix */
        Mat4One(mat);
        
-       mat[0][0] = tmat[0][0] * size[0];
-       mat[0][1] = tmat[0][1] * size[1];
-       mat[0][2] = tmat[0][2] * size[2];
-       
-       mat[1][0] = tmat[1][0] * size[0];
-       mat[1][1] = tmat[1][1] * size[1];
-       mat[1][2] = tmat[1][2] * size[2];
+       /* make rotation + scaling part */
+       EulToMat3(eul, rmat);
+       SizeToMat3(size, smat);
+       Mat3MulMat3(tmat, rmat, smat);
        
-       mat[2][0] = tmat[2][0] * size[0];
-       mat[2][1] = tmat[2][1] * size[1];
-       mat[2][2] = tmat[2][2] * size[2];
+       /* copy rot/scale part to output matrix*/
+       Mat4CpyMat3(mat, tmat);
        
+       /* copy location to matrix */
        mat[3][0] = loc[0];
        mat[3][1] = loc[1];
        mat[3][2] = loc[2];
 }
 
 /* make a 4x4 matrix out of 3 transform components */
+/* matrices are made in the order: scale * rot * loc */
 void LocQuatSizeToMat4(float mat[][4], float loc[3], float quat[4], float size[3])
 {
-       float eul[3];
+       float rmat[3][3], smat[3][3], tmat[3][3];
        
-       /* convert quaternion component to euler 
-        *      NOTE: not as good as using quat directly. Todo for later.
-        */
-       QuatToEul(quat, eul);
+       /* initialise new matrix */
+       Mat4One(mat);
+       
+       /* make rotation + scaling part */
+       QuatToMat3(quat, rmat);
+       SizeToMat3(size, smat);
+       Mat3MulMat3(tmat, rmat, smat);
+       
+       /* copy rot/scale part to output matrix*/
+       Mat4CpyMat3(mat, tmat);
        
-       /* make into matrix using exisiting code */
-       LocEulSizeToMat4(mat, loc, eul, size);
+       /* copy location to matrix */
+       mat[3][0] = loc[0];
+       mat[3][1] = loc[1];
+       mat[3][2] = loc[2];
 }