home *** CD-ROM | disk | FTP | other *** search
/ Apple Developer Connection 1998 Fall: Game Toolkit / Disc.iso / SDKs / Third Party SDKs / ATI RAVE SDK / Samples / Strip Test / inc / matrix.h < prev   
Encoding:
C/C++ Source or Header  |  1998-01-18  |  11.0 KB  |  292 lines  |  [TEXT/CWIE]
  1. /****************************************************************/
  2. /* headers                                                      */
  3. /****************************************************************/
  4. #include <math.h>
  5. #include "macros.h"
  6.  
  7. /****************************************************************/
  8. /* defines                                                        */
  9. /****************************************************************/
  10. #define X            0
  11. #define Y            1
  12. #define Z            2
  13. #define W            3
  14.  
  15. /******************************************************************/
  16. #define print_mat( mat, str )                                                            \
  17. {                                                                                        \
  18.     printf( "%s:\n", (str) ? (str) : "" );                                                \
  19.     print_vect( (mat)[0], NULL );                                                        \
  20.     print_vect( (mat)[1], NULL );                                                        \
  21.     print_vect( (mat)[2], NULL );                                                        \
  22.     print_vect( (mat)[3], NULL );                                                        \
  23. }
  24.  
  25. /******************************************************************/
  26. #define copy_matrix( dst_mat, src_mat )                                                    \
  27. {                                                                                        \
  28.     copy_vect( (dst_mat)[0], (src_mat)[0] );                                            \
  29.     copy_vect( (dst_mat)[1], (src_mat)[1] );                                            \
  30.     copy_vect( (dst_mat)[2], (src_mat)[2] );                                            \
  31.     copy_vect( (dst_mat)[3], (src_mat)[3] );                                            \
  32. }
  33.             
  34. /******************************************************************/
  35. #define ident_mat( mat )                                                                \
  36. {                                                                                        \
  37.     (mat)[0][1] = (mat)[0][2] = (mat)[0][3] = 0.0;                                        \
  38.     (mat)[1][0] = (mat)[1][2] = (mat)[1][3] = 0.0;                                        \
  39.     (mat)[2][0] = (mat)[2][1] = (mat)[2][3] = 0.0;                                        \
  40.     (mat)[3][0] = (mat)[3][1] = (mat)[3][2] = 0.0;                                        \
  41.     (mat)[0][0] = (mat)[1][1] = (mat)[2][2] = (mat)[3][3] = 1.0;                        \
  42. }
  43.  
  44. /******************************************************************/
  45. #define init_trans( mat, tx, ty, tz )                                                    \
  46. {                                                                                        \
  47.     ident_mat( (mat) );                                                                    \
  48.     (mat)[0][3] = (tx);                                                                    \
  49.     (mat)[1][3] = (ty);                                                                    \
  50.     (mat)[2][3] = (tz);                                                                    \
  51. }
  52.  
  53. /******************************************************************/
  54. #define init_scale( mat, sx, sy, sz )                                                    \
  55. {                                                                                        \
  56.     ident_mat( (mat) );                                                                    \
  57.     (mat)[0][0] = (sx);                                                                    \
  58.     (mat)[1][1] = (sy);                                                                    \
  59.     (mat)[2][2] = (sz);                                                                    \
  60. }
  61.  
  62. /******************************************************************/
  63. #define init_xrot( mat, theta )                                                            \
  64. {                                                                                        \
  65.     FLOAT32 cos_theta = cos( DEG2RAD(theta) );                                            \
  66.     FLOAT32 sin_theta = sin( DEG2RAD(theta) );                                            \
  67.     ident_mat( (mat) );                                                                    \
  68.     (mat)[1][1] = cos_theta;                                                            \
  69.     (mat)[1][2] = -sin_theta;                                                            \
  70.     (mat)[2][1] = sin_theta;                                                            \
  71.     (mat)[2][2] = cos_theta;                                                            \
  72. }
  73.  
  74. /******************************************************************/
  75. #define init_yrot( mat, theta )                                                            \
  76. {                                                                                        \
  77.     FLOAT32 cos_theta = cos( DEG2RAD(theta) );                                            \
  78.     FLOAT32 sin_theta = sin( DEG2RAD(theta) );                                            \
  79.     ident_mat( (mat) );                                                                    \
  80.     (mat)[0][0] = cos_theta;                                                            \
  81.     (mat)[0][2] = sin_theta;                                                            \
  82.     (mat)[2][0] = -sin_theta;                                                            \
  83.     (mat)[2][2] = cos_theta;                                                            \
  84. }
  85.  
  86. /******************************************************************/
  87. #define init_zrot( mat, theta )                                                            \
  88. {                                                                                        \
  89.     FLOAT32 cos_theta = cos( DEG2RAD(theta) );                                            \
  90.     FLOAT32 sin_theta = sin( DEG2RAD(theta) );                                            \
  91.     ident_mat( (mat) );                                                                    \
  92.     (mat)[0][0] = cos_theta;                                                            \
  93.     (mat)[0][1] = -sin_theta;                                                            \
  94.     (mat)[1][0] = sin_theta;                                                            \
  95.     (mat)[1][1] = cos_theta;                                                            \
  96. }
  97.  
  98. /******************************************************************/
  99. #define transpose_matrix( src_mat, dst_mat )                                            \
  100. {                                                                                        \
  101.     int i, j;                                                                            \
  102.     for( i = 0; i < 4; i++ )                                                            \
  103.         for( j = 0; j < 4; j++ )                                                        \
  104.             (dst_mat)[j][i] = (src_mat)[i][j];                                            \
  105. }
  106.             
  107.  
  108. /******************************************************************/
  109. #define trans_mat( mat, tx, ty, tz )                                                    \
  110. {                                                                                        \
  111.     MATRIX trans, tmp;                                                                    \
  112.     init_trans( trans, (tx), (ty), (tz) );                                                \
  113.     copy_matrix( tmp, (mat) );                                                            \
  114.     matrix_mult( tmp, trans, (mat) );                                                    \
  115. }
  116.  
  117. /******************************************************************/
  118. #define scale_mat( mat, sx, sy, sz )                                                    \
  119. {                                                                                        \
  120.     MATRIX scale, tmp;                                                                    \
  121.     init_scale( scale, (sx), (sy), (sz) );                                                \
  122.     copy_matrix( tmp, (mat) );                                                            \
  123.     matrix_mult( tmp, scale, (mat) );                                                    \
  124. }
  125.  
  126. /******************************************************************/
  127. #define xrot_mat( mat, theta )                                                            \
  128. {                                                                                        \
  129.     MATRIX rot, tmp;                                                                    \
  130.     init_xrot( rot, (theta) );                                                            \
  131.     copy_matrix( tmp, (mat) );                                                            \
  132.     matrix_mult( tmp, rot, (mat) );                                                        \
  133. }
  134.     
  135. /******************************************************************/
  136. #define yrot_mat( mat, theta )                                                            \
  137. {                                                                                        \
  138.     MATRIX rot, tmp;                                                                    \
  139.     init_yrot( rot, (theta) );                                                            \
  140.     copy_matrix( tmp, (mat) );                                                            \
  141.     matrix_mult( tmp, rot, (mat) );                                                        \
  142. }
  143.  
  144. /******************************************************************/
  145. #define zrot_mat( mat, theta )                                                            \
  146. {                                                                                        \
  147.     MATRIX rot, tmp;                                                                    \
  148.     init_zrot( rot, (theta) );                                                            \
  149.     copy_matrix( tmp, (mat) );                                                            \
  150.     matrix_mult( tmp, rot, (mat) );                                                        \
  151. }
  152.  
  153. /******************************************************************/
  154. #define set_vect( v, x, y, z, w )    (v)[X]=(x), (v)[Y]=(y), (v)[Z]=(z), (v)[W]=(w)
  155.  
  156. /******************************************************************/
  157. #define print_vect( v, str )        printf( "%s:\n%5.3lf  %5.3lf  %5.3lf %5.3lf\n", (str)?(str):"", (v)[X], (v)[Y], (v)[Z], (v)[W] )
  158.  
  159. /******************************************************************/
  160. #define dot( a, b )                   ( (a)[X]*(b)[X] + (a)[Y]*(b)[Y] + (a)[Z]*(b)[Z] )
  161.  
  162. /******************************************************************/
  163. #define cross( a, b, n )                                                                \
  164. {                                                                                        \
  165.     n[X] = a[Y]*b[Z] - a[Z]*b[Y];                                                        \
  166.     n[Y] = a[Z]*b[X] - a[X]*b[Z];                                                        \
  167.     n[Z] = a[X]*b[Y] - a[Y]*b[X];                                                        \
  168.     n[W] = 1.0;                                                                            \
  169. }
  170.  
  171. /******************************************************************/
  172. #define veclen( v )    sqrt( SQR((v)[X]) + SQR((v)[Y]) + SQR((v)[Z]) )    
  173.  
  174. /******************************************************************/
  175. #define dist( v1, v2 )    sub_vect( (v2), (v1), _util_vect ), veclen( _util_vect );
  176.  
  177. /******************************************************************/
  178. #define eq_vect( v1, v2, tolerance )    (ABS(DOT( (v1), (v2) ) - 1.0) > (tolerance))
  179.  
  180. /******************************************************************/
  181. #define norm( v )                                                                        \
  182. {                                                                                        \
  183.     _util_FLOAT321 = veclen(v);                                                            \
  184.     if( !FLT_ZERO(_util_FLOAT321) )                                                        \
  185.     {                                                                                    \
  186.         _util_FLOAT322 = 1.0/_util_FLOAT321;                                                \
  187.         mult_vect( _util_FLOAT322, (v) );                                                \
  188.     }                                                                                    \
  189. }
  190.  
  191. /******************************************************************/
  192. #define copy_vect( v1, v2 )    (v1)[X] = (v2)[X], (v1)[Y] = (v2)[Y], (v1)[Z] = (v2)[Z], (v1)[W] = (v2)[W]
  193.  
  194. /******************************************************************/
  195. #define sub_vect( v1, v2, result )                                                        \
  196. {                                                                                        \
  197.     (result)[X] = (v1)[X] - (v2)[X];                                                    \
  198.     (result)[Y] = (v1)[Y] - (v2)[Y];                                                    \
  199.     (result)[Z] = (v1)[Z] - (v2)[Z];                                                    \
  200.     (result)[W] = 1.0;                                                                    \
  201. }
  202.  
  203. /******************************************************************/
  204. #define add_vect( v1, v2, result )                                                        \
  205. {                                                                                        \
  206.     (result)[X] = (v1)[X] + (v2)[X];                                                    \
  207.     (result)[Y] = (v1)[Y] + (v2)[Y];                                                    \
  208.     (result)[Z] = (v1)[Z] + (v2)[Z];                                                    \
  209.     (result)[W] = 1.0;                                                                    \
  210. }
  211.  
  212. /******************************************************************/
  213. #define mult_vect( f, v )    (v)[X] *= (f), (v)[Y] *= (f), (v)[Z] *= (f)
  214.  
  215. /******************************************************************/
  216. #define vect_mult_vect( v1, v2, result )                                                \
  217. {                                                                                        \
  218.     (result)[X] = (v1)[X] * (v2)[X];                                                    \
  219.     (result)[Y] = (v1)[Y] * (v2)[Y];                                                    \
  220.     (result)[Z] = (v1)[Z] * (v2)[Z];                                                    \
  221.     (result)[W] = (v1)[W] * (v2)[W];                                                    \
  222. }
  223.  
  224. /******************************************************************/
  225. #define vect_mult_vect_add( v1, v2, result )                                            \
  226. {                                                                                        \
  227.     (result)[X] += (v1)[X] * (v2)[X];                                                    \
  228.     (result)[Y] += (v1)[Y] * (v2)[Y];                                                    \
  229.     (result)[Z] += (v1)[Z] * (v2)[Z];                                                    \
  230.     (result)[W] += (v1)[W] * (v2)[W];                                                    \
  231. }
  232.  
  233. /******************************************************************/
  234. #define div_vect( v, f )                                                                \
  235. {                                                                                        \
  236.     if( !FLT_ZERO(f) )                                                                    \
  237.     {                                                                                    \
  238.         _util_FLOAT321 = 1.0/(f);                                                        \
  239.         mult_vect( _util_FLOAT321, (v) );                                                \
  240.     }                                                                                    \
  241. }
  242.  
  243. /******************************************************************/
  244. #define homo_vect( v )                                                                    \
  245. {                                                                                        \
  246.     _util_FLOAT321 = (FLT_ZERO((v)[W]))    ? 1000.0 : 1.0/(v)[W];                            \
  247.     (v)[X] *= _util_FLOAT321;                                                            \
  248.     (v)[Y] *= _util_FLOAT321;                                                            \
  249.     (v)[Z] *= -1; /*_util_FLOAT321;*/                                                    \
  250.     (v)[W] = 1.0;                                                                        \
  251. }
  252.  
  253. /******************************************************************/
  254. #define avg_vect( v1, v2, result )                                                        \
  255. {                                                                                        \
  256.     (result)[X] = ((v1)[X] + (v2)[X])*0.5;                                                \
  257.     (result)[Y] = ((v1)[Y] + (v2)[Y])*0.5;                                                \
  258.     (result)[Z] = ((v1)[Z] + (v2)[Z])*0.5;                                                \
  259.     (result)[W] = 1.0;                                                                    \
  260. }
  261.  
  262. /******************************************************************/
  263. #define clamp_vect( v, l, h )                                                            \
  264. {                                                                                        \
  265.     (v)[0] = CLAMP( (v)[0], (l), (h) );                                                    \
  266.     (v)[1] = CLAMP( (v)[1], (l), (h) );                                                    \
  267.     (v)[2] = CLAMP( (v)[2], (l), (h) );                                                    \
  268. }
  269.  
  270. /****************************************************************/
  271. /*  typedefs                                                    */
  272. /****************************************************************/
  273. typedef float FLOAT32;
  274. typedef FLOAT32 VECT[4];
  275. typedef FLOAT32 MATRIX[4][4];
  276.  
  277. /****************************************************************/
  278. /* function prototypes                                          */
  279. /****************************************************************/
  280. extern void matrix_mult( MATRIX, MATRIX, MATRIX );
  281. extern void vect_matrix_mult( VECT, MATRIX, VECT );
  282. extern void rotate_about_axis( VECT axis, FLOAT32 angle, MATRIX M );
  283. extern int intersect_unit_sphere( VECT hit );
  284.  
  285. /****************************************************************/
  286. /* global variables                                             */
  287. /****************************************************************/
  288. extern VECT     _util_vect;
  289. extern FLOAT32     _util_FLOAT321;
  290. extern FLOAT32     _util_FLOAT322;
  291.  
  292.