home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / IRIT / POLY3DS.ZIP / GENMAT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-05  |  6.1 KB  |  156 lines
  1. /*****************************************************************************
  2. * General matrix manipulation routines.                         *
  3. *                                         *
  4. * Written by:  Gershon Elber                   Ver 1.0,    June 1988    *
  5. *****************************************************************************/
  6.  
  7. #include <math.h>
  8. #include "genmat.h"
  9.  
  10. /*****************************************************************************
  11. * Routine to generate a 4*4 unit matrix:                                     *
  12. *****************************************************************************/
  13. void GenUnitMat(MatrixType Mat)
  14. {
  15.     int i, j;
  16.  
  17.     for (i=0; i<4; i++) for (j=0; j<4; j++)
  18.         if (i==j) Mat[i][j] = 1.0;
  19.         else      Mat[i][j] = 0.0;
  20. }
  21.  
  22. /*****************************************************************************
  23. * Routine to generate a 4*4 matrix to translate in Tx, Ty, Tz amounts.       *
  24. *****************************************************************************/
  25. void GenMatTrans(double Tx, double Ty, double Tz, MatrixType Mat)
  26. {
  27.      GenUnitMat(Mat);                                /* Make it unit matrix. */
  28.      Mat[3][0] = Tx;
  29.      Mat[3][1] = Ty;
  30.      Mat[3][2] = Tz;
  31. }
  32.  
  33. /*****************************************************************************
  34. * Routine to generate a 4*4 matrix to Scale x, y, z in Sx, Sy, Sz amounts.   *
  35. *****************************************************************************/
  36. void GenMatScale(double Sx, double Sy, double Sz, MatrixType Mat)
  37. {
  38.      GenUnitMat(Mat);                                /* Make it unit matrix. */
  39.      Mat[0][0] = Sx;
  40.      Mat[1][1] = Sy;
  41.      Mat[2][2] = Sz;
  42. }
  43.  
  44. /*****************************************************************************
  45. * Routine to generate a 4*4 matrix to Rotate around X with angle of Teta.    *
  46. * Note Teta must be given in radians.                                        *
  47. *****************************************************************************/
  48. void GenMatRotX1(double Teta, MatrixType Mat)
  49. {
  50.     double CTeta, STeta;
  51.  
  52.     CTeta = cos(Teta);
  53.     STeta = sin(Teta);
  54.     GenMatRotX(CTeta, STeta, Mat);
  55. }
  56.  
  57. /*****************************************************************************
  58. * Routine to generate a 4*4 matrix to Rotate around X with angle of Teta.    *
  59. *****************************************************************************/
  60. void GenMatRotX(double CosTeta, double SinTeta, MatrixType Mat)
  61. {
  62.      GenUnitMat(Mat);                                /* Make it unit matrix. */
  63.      Mat[1][1] = CosTeta;
  64.      Mat[1][2] = SinTeta;
  65.      Mat[2][1] = -SinTeta;
  66.      Mat[2][2] = CosTeta;
  67. }
  68.  
  69. /*****************************************************************************
  70. * Routine to generate a 4*4 matrix to Rotate around Y with angle of Teta.    *
  71. * Note Teta must be given in radians.                                        *
  72. *****************************************************************************/
  73. void GenMatRotY1(double Teta, MatrixType Mat)
  74. {
  75.     double CTeta, STeta;
  76.  
  77.     CTeta = cos(Teta);
  78.     STeta = sin(Teta);
  79.     GenMatRotY(CTeta, STeta, Mat);
  80. }
  81.  
  82. /*****************************************************************************
  83. * Routine to generate a 4*4 matrix to Rotate around Y with angle of Teta.    *
  84. *****************************************************************************/
  85. void GenMatRotY(double CosTeta, double SinTeta, MatrixType Mat)
  86. {
  87.      GenUnitMat(Mat);                                /* Make it unit matrix. */
  88.      Mat[0][0] = CosTeta;
  89.      Mat[0][2] = -SinTeta;
  90.      Mat[2][0] = SinTeta;
  91.      Mat[2][2] = CosTeta;
  92. }
  93.  
  94. /*****************************************************************************
  95. * Routine to generate a 4*4 matrix to Rotate around Z with angle of Teta.    *
  96. * Note Teta must be given in radians.                                        *
  97. *****************************************************************************/
  98. void GenMatRotZ1(double Teta, MatrixType Mat)
  99. {
  100.     double CTeta, STeta;
  101.  
  102.     CTeta = cos(Teta);
  103.     STeta = sin(Teta);
  104.     GenMatRotZ(CTeta, STeta, Mat);
  105. }
  106.  
  107. /*****************************************************************************
  108. * Routine to generate a 4*4 matrix to Rotate around Z with angle of Teta.    *
  109. *****************************************************************************/
  110. void GenMatRotZ(double CosTeta, double SinTeta, MatrixType Mat)
  111. {
  112.      GenUnitMat(Mat);                                /* Make it unit matrix. */
  113.      Mat[0][0] = CosTeta;
  114.      Mat[0][1] = SinTeta;
  115.      Mat[1][0] = -SinTeta;
  116.      Mat[1][1] = CosTeta;
  117. }
  118.  
  119. /*****************************************************************************
  120. * Routine to multiply 2 4by4 matrices:                                       *
  121. * Note MatRes might be one of Mat1 or Mat2 - it is only updated in the end!  *
  122. *****************************************************************************/
  123. void MultTwo4by4(MatrixType MatRes, MatrixType Mat1, MatrixType Mat2)
  124. {
  125.     int i, j, k;
  126.     MatrixType MatResTemp;
  127.  
  128.     for (i=0; i<4; i++) for (j=0; j<4; j++) {
  129.         MatResTemp[i][j] = 0;
  130.         for (k=0; k<4; k++) MatResTemp[i][j] += Mat1[i][k] * Mat2[k][j];
  131.     }
  132.     for (i=0; i<4; i++) for (j=0; j<4; j++) MatRes[i][j] = MatResTemp[i][j];
  133. }
  134.  
  135. /*****************************************************************************
  136. * Routine to multiply Vector by 4by4 matrix:                                 *
  137. * The Vector has only 3 components (X, Y, Z) and it is assumed that W = 1    *
  138. * Note VRes might be Vec as it is only updated in the end.                   *
  139. *****************************************************************************/
  140. void MultVecby4by4(double VRes[3], float Vec[3], MatrixType Mat)
  141. {
  142.     int i, j;
  143.     double CalcW = Mat[3][3];
  144.     double VTemp[3];
  145.  
  146.     for (i=0; i<3; i++) {
  147.         VTemp[i] = Mat[3][i];         /* Initiate it with the weight factor. */
  148.         for (j=0; j<3; j++) VTemp[i] += Vec[j] * Mat[j][i];
  149.     }
  150.  
  151.     for (i=0; i<3; i++) CalcW += Vec[i] * Mat[i][3];
  152.     if (CalcW == 0) CalcW = 1 / INFINITY;
  153.  
  154.     for (i=0; i<3; i++) VRes[i] = VTemp[i]/CalcW;
  155. }
  156.