home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / MATRICES.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  9.9 KB  |  364 lines
  1. /****************************************************************************
  2. *                matrices.c
  3. *
  4. *  This module contains code to manipulate 4x4 matrices.
  5. *
  6. *  from Persistence of Vision Raytracer 
  7. *  Copyright 1992 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  Copying, distribution and legal info is in the file povlegal.doc which
  10. *  should be distributed with this file. If povlegal.doc is not available
  11. *  or for more info please contact:
  12. *
  13. *       Drew Wells [POV-Team Leader] 
  14. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  15. *       Phone: (213) 254-4041
  16. * 
  17. * This program is based on the popular DKB raytracer version 2.12.
  18. * DKBTrace was originally written by David K. Buck.
  19. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  20. *
  21. *****************************************************************************/
  22.  
  23.  
  24. #include "frame.h"
  25. #include "vector.h"
  26. #include "povproto.h"
  27.  
  28. void MZero (result)
  29. MATRIX *result;
  30. {
  31.    /* Initialize the matrix to the following values:
  32.    0.0   0.0   0.0   0.0
  33.    0.0   0.0   0.0   0.0
  34.    0.0   0.0   0.0   0.0
  35.    0.0   0.0   0.0   0.0
  36. */
  37.    register int i, j;
  38.  
  39.    for (i = 0 ; i < 4 ; i++)
  40.       for (j = 0 ; j < 4 ; j++)
  41.          (*result)[i][j] = 0.0;
  42. }
  43.  
  44. void MIdentity (result)
  45. MATRIX *result;
  46. {
  47.    /* Initialize the matrix to the following values:
  48.    1.0   0.0   0.0   0.0
  49.    0.0   1.0   0.0   0.0
  50.    0.0   0.0   1.0   0.0
  51.    0.0   0.0   0.0   1.0
  52. */
  53.    register int i, j;
  54.  
  55.    for (i = 0 ; i < 4 ; i++)
  56.       for (j = 0 ; j < 4 ; j++)
  57.          if (i == j)
  58.             (*result)[i][j] = 1.0;
  59.          else
  60.             (*result)[i][j] = 0.0;
  61. }
  62.  
  63. void MTimes (result, matrix1, matrix2)
  64. MATRIX *result, *matrix1, *matrix2;
  65. {
  66.    register int i, j, k;
  67.    MATRIX temp_matrix;
  68.  
  69.    for (i = 0 ; i < 4 ; i++)
  70.       for (j = 0 ; j < 4 ; j++) {
  71.          temp_matrix[i][j] = 0.0;
  72.          for (k = 0 ; k < 4 ; k++)
  73.             temp_matrix[i][j] += (*matrix1)[i][k] * (*matrix2)[k][j];
  74.       }
  75.  
  76.    for (i = 0 ; i < 4 ; i++)
  77.       for (j = 0 ; j < 4 ; j++)
  78.          (*result)[i][j] = temp_matrix[i][j];
  79.  
  80.    COOPERATE    
  81. }
  82.  
  83. /*  AAC - These are not used, so they are commented out to save code space...
  84.  
  85. void MAdd (result, matrix1, matrix2)
  86.    MATRIX *result, *matrix1, *matrix2;
  87.    {
  88.    register int i, j;
  89.  
  90.    for (i = 0 ; i < 4 ; i++)
  91.       for (j = 0 ; j < 4 ; j++)
  92.          (*result)[i][j] = (*matrix1)[i][j] + (*matrix2)[i][j];
  93.    }
  94.  
  95. void MSub (result, matrix1, matrix2)
  96.    MATRIX *result, *matrix1, *matrix2;
  97.    {
  98.    register int i, j;
  99.  
  100.    for (i = 0 ; i < 4 ; i++)
  101.       for (j = 0 ; j < 4 ; j++)
  102.          (*result)[i][j] = (*matrix1)[i][j] - (*matrix2)[i][j];
  103.    }
  104.  
  105. void MScale (result, matrix1, amount)
  106. MATRIX *result, *matrix1;
  107. DBL amount;
  108. {
  109.    register int i, j;
  110.  
  111.    for (i = 0 ; i < 4 ; i++)
  112.       for (j = 0 ; j < 4 ; j++)
  113.      if (amount == 1.0)
  114.         (*result)[i][j] = (*matrix1)[i][j]; * just copy *
  115.      else
  116.             (*result)[i][j] = (*matrix1)[i][j] * amount;
  117.    return;
  118. }
  119. ... up to here! */
  120.  
  121. void MTranspose (result, matrix1)
  122. MATRIX *result, *matrix1;
  123. {
  124.    register int i, j;
  125.    MATRIX temp_matrix;
  126.  
  127.    for (i = 0 ; i < 4 ; i++)
  128.       for (j = 0 ; j < 4 ; j++)
  129.          temp_matrix[i][j] = (*matrix1)[j][i];
  130.  
  131.    for (i = 0 ; i < 4 ; i++)
  132.       for (j = 0 ; j < 4 ; j++)
  133.          (*result)[i][j] = temp_matrix[i][j];
  134. }
  135.  
  136.  
  137. void MTransformVector (result, vector, transformation)
  138. VECTOR *result, *vector;
  139. TRANSFORMATION *transformation;
  140. {
  141.    register int i;
  142.    DBL answer_array[4];
  143.    MATRIX *matrix;
  144.  
  145.    matrix = (MATRIX *) transformation -> matrix;
  146.  
  147.    for (i = 0 ; i < 4 ; i++)
  148.       answer_array[i] = vector -> x * (*matrix)[0][i]
  149.       + vector -> y * (*matrix)[1][i]
  150.       + vector -> z * (*matrix)[2][i]
  151.       + (*matrix)[3][i];
  152.  
  153.    result -> x  = answer_array[0];
  154.    result -> y  = answer_array[1];
  155.    result -> z  = answer_array[2];
  156. }
  157.  
  158. void MInverseTransformVector (result, vector, transformation)
  159. VECTOR *result, *vector;
  160. TRANSFORMATION *transformation;
  161. {
  162.    register int i;
  163.    DBL answer_array[4];
  164.    MATRIX *matrix;
  165.  
  166.    matrix = (MATRIX *) transformation -> inverse;
  167.  
  168.    for (i = 0 ; i < 4 ; i++)
  169.       answer_array[i] = vector -> x * (*matrix)[0][i]
  170.       + vector -> y * (*matrix)[1][i]
  171.       + vector -> z * (*matrix)[2][i]
  172.       + (*matrix)[3][i];
  173.  
  174.    result -> x  = answer_array[0];
  175.    result -> y  = answer_array[1];
  176.    result -> z  = answer_array[2];
  177. }
  178.  
  179. void MTransVector (result, vector, transformation)
  180. VECTOR *result, *vector;
  181. TRANSFORMATION *transformation;
  182. {
  183.    register int i;
  184.    DBL answer_array[4];
  185.    MATRIX *matrix;
  186.  
  187.    matrix = (MATRIX *) transformation -> matrix;
  188.  
  189.    for (i = 0 ; i < 4 ; i++)
  190.       answer_array[i] = vector -> x * (*matrix)[0][i]
  191.       + vector -> y * (*matrix)[1][i]
  192.       + vector -> z * (*matrix)[2][i];
  193.  
  194.    result -> x  = answer_array[0];
  195.    result -> y  = answer_array[1];
  196.    result -> z  = answer_array[2];
  197. }
  198.  
  199. void MInvTransVector (result, vector, transformation)
  200. VECTOR *result, *vector;
  201. TRANSFORMATION *transformation;
  202. {
  203.    register int i;
  204.    DBL answer_array[4];
  205.    MATRIX *matrix;
  206.  
  207.    matrix = (MATRIX *) transformation -> inverse;
  208.  
  209.    for (i = 0 ; i < 4 ; i++)
  210.       answer_array[i] = vector -> x * (*matrix)[0][i]
  211.       + vector -> y * (*matrix)[1][i]
  212.       + vector -> z * (*matrix)[2][i];
  213.  
  214.    result -> x  = answer_array[0];
  215.    result -> y  = answer_array[1];
  216.    result -> z  = answer_array[2];
  217. }
  218.  
  219. void MTransNormal (result, vector, transformation)
  220. VECTOR *result, *vector;
  221. TRANSFORMATION *transformation;
  222. {
  223.    register int i;
  224.    DBL answer_array[3];
  225.    MATRIX *matrix;
  226.  
  227.    matrix = (MATRIX *) transformation -> inverse;
  228.  
  229.    for (i = 0 ; i < 3 ; i++)
  230.       answer_array[i] = vector -> x * (*matrix)[i][0]
  231.       + vector -> y * (*matrix)[i][1]
  232.       + vector -> z * (*matrix)[i][2];
  233.  
  234.    result -> x  = answer_array[0];
  235.    result -> y  = answer_array[1];
  236.    result -> z  = answer_array[2];
  237. }
  238.  
  239. void Get_Scaling_Transformation (result, vector)
  240. TRANSFORMATION *result;
  241. VECTOR *vector;
  242. {
  243.    MIdentity ((MATRIX *)result -> matrix);
  244.    (result -> matrix)[0][0] = vector -> x;
  245.    (result -> matrix)[1][1] = vector -> y;
  246.    (result -> matrix)[2][2] = vector -> z;
  247.  
  248.    MIdentity ((MATRIX *)result -> inverse);
  249.    (result -> inverse)[0][0] = 1.0 / vector -> x;
  250.    (result -> inverse)[1][1]= 1.0 / vector -> y;
  251.    (result -> inverse)[2][2] = 1.0 / vector -> z;
  252. }
  253.  
  254. /* AAC - This is not used, so it's commented out...
  255.  
  256. void Get_Inversion_Transformation (result)
  257.    TRANSFORMATION *result;
  258.    {
  259.    MIdentity ((MATRIX *)result -> matrix);
  260.    (result -> matrix)[0][0] = -1.0;
  261.    (result -> matrix)[1][1] = -1.0;
  262.    (result -> matrix)[2][2] = -1.0;
  263.    (result -> matrix)[3][3] = -1.0;
  264.  
  265.  
  266.    (result -> inverse)[0][0] = -1.0;
  267.    (result -> inverse)[1][1] = -1.0;
  268.    (result -> inverse)[2][2] = -1.0;
  269.    (result -> inverse)[3][3] = -1.0;
  270.    }
  271. ... up to here! */
  272.  
  273. void Get_Translation_Transformation (transformation, vector)
  274. TRANSFORMATION *transformation;
  275. VECTOR *vector;
  276. {
  277.    MIdentity ((MATRIX *)transformation -> matrix);
  278.    (transformation -> matrix)[3][0] = vector -> x;
  279.    (transformation -> matrix)[3][1] = vector -> y;
  280.    (transformation -> matrix)[3][2] = vector -> z;
  281.  
  282.    MIdentity ((MATRIX *)transformation -> inverse);
  283.    (transformation -> inverse)[3][0] = 0.0 - vector -> x;
  284.    (transformation -> inverse)[3][1] = 0.0 - vector -> y;
  285.    (transformation -> inverse)[3][2] = 0.0 - vector -> z;
  286. }
  287.  
  288. void Get_Rotation_Transformation (transformation, vector)
  289. TRANSFORMATION *transformation;
  290. VECTOR *vector;
  291. {
  292.    MATRIX Matrix;
  293.    VECTOR Radian_Vector;
  294.    register DBL cosx, cosy, cosz, sinx, siny, sinz;
  295.  
  296.    VScale (Radian_Vector, *vector, M_PI/180.0);
  297.    MIdentity ((MATRIX *)transformation -> matrix);
  298.    cosx = cos (Radian_Vector.x);
  299.    sinx = sin (Radian_Vector.x);
  300.    cosy = cos (Radian_Vector.y);
  301.    siny = sin (Radian_Vector.y);
  302.    cosz = cos (Radian_Vector.z);
  303.    sinz = sin (Radian_Vector.z);
  304.  
  305.    (transformation -> matrix) [1][1] = cosx;
  306.    (transformation -> matrix) [2][2] = cosx;
  307.    (transformation -> matrix) [1][2] = sinx;
  308.    (transformation -> matrix) [2][1] = 0.0 - sinx;
  309.    MTranspose ((MATRIX *)transformation -> inverse, (MATRIX *)transformation -> matrix);
  310.  
  311.    MIdentity ((MATRIX *)Matrix);
  312.    Matrix [0][0] = cosy;
  313.    Matrix [2][2] = cosy;
  314.    Matrix [0][2] = 0.0 - siny;
  315.    Matrix [2][0] = siny;
  316.    MTimes ((MATRIX *)transformation -> matrix, (MATRIX *)transformation -> matrix, (MATRIX *)Matrix);
  317.    MTranspose ((MATRIX *)Matrix, (MATRIX *)Matrix);
  318.    MTimes ((MATRIX *)transformation -> inverse, (MATRIX *)Matrix, (MATRIX *)transformation -> inverse);
  319.  
  320.    MIdentity ((MATRIX *)Matrix);
  321.    Matrix [0][0] = cosz;
  322.    Matrix [1][1] = cosz;
  323.    Matrix [0][1] = sinz;
  324.    Matrix [1][0] = 0.0 - sinz;
  325.    MTimes ((MATRIX *)transformation -> matrix, (MATRIX *)transformation -> matrix, (MATRIX *)Matrix);
  326.    MTranspose ((MATRIX *)Matrix, (MATRIX *)Matrix);
  327.    MTimes ((MATRIX *)transformation -> inverse, (MATRIX *)Matrix, (MATRIX *)transformation -> inverse);
  328. }
  329.  
  330. /* AAC - This is not used so it's commented out...
  331.  
  332. void Get_Look_At_Transformation (result, Look_At, Up, Right)
  333.    TRANSFORMATION *result;
  334.    VECTOR *Look_At, *Up, *Right;
  335.    {
  336.    MIdentity ((MATRIX *)result -> inverse);
  337.    (result -> matrix)[0][0] = Right->x;
  338.    (result -> matrix)[0][1] = Right->y;
  339.    (result -> matrix)[0][2] = Right->z;
  340.    (result -> matrix)[1][0] = Up->x;
  341.    (result -> matrix)[1][1] = Up->y;
  342.    (result -> matrix)[1][2] = Up->z;
  343.    (result -> matrix)[2][0] = Look_At->x;
  344.    (result -> matrix)[2][1] = Look_At->y;
  345.    (result -> matrix)[2][2] = Look_At->z;
  346.  
  347.    MIdentity ((MATRIX *)result -> matrix);
  348.    MTranspose ((MATRIX *)result -> matrix, (MATRIX *)result -> inverse);   
  349.    }
  350.  
  351. ... up to here! */
  352.  
  353. void Compose_Transformations (Original_Transformation, New_Transformation)
  354. TRANSFORMATION *Original_Transformation, *New_Transformation;
  355. {
  356.    MTimes ((MATRIX *)Original_Transformation -> matrix,
  357.       (MATRIX *)Original_Transformation -> matrix,
  358.       (MATRIX *)New_Transformation -> matrix);
  359.  
  360.    MTimes ((MATRIX *)Original_Transformation -> inverse,
  361.       (MATRIX *)New_Transformation -> inverse,
  362.       (MATRIX *)Original_Transformation -> inverse);
  363. }
  364.