home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Libraries / 3DGPL 1.0 / CODE / TRANS / TRANS-FX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-08  |  10.8 KB  |  292 lines  |  [TEXT/MACA]
  1. /** 3DGPL *************************************************\
  2.  *  ()                                                    *
  3.  *  3-D transformations of coordinates using fixed point. *
  4.  *                                                        *
  5.  *  Defines:                                              *
  6.  *   T_init_math             Creating sin/cos tables;     *
  7.  *                                                        *
  8.  *   T_translation           Shifting of coordinates;     *
  9.  *   T_scaling               Scaling coordinates;         *
  10.  *                                                        *
  11.  *   T_set_world_rotation    Viewer's rotation;           *
  12.  *   T_world_rotation        Transforming coordinates;    *
  13.  *   T_set_self_rotation     Object rotation;             *
  14.  *   T_self_rotation         Transforming coordinates;    *
  15.  *                                                        *
  16.  *   T_perspective           Transform to perspective.    *
  17.  *                                                        *
  18.  *  Internals:                                            *
  19.  *   TI_float2fixed          Converting float to fixed.   *
  20.  *                                                        *
  21.  *  (6/1995) By Sergei Savchenko. (savs@cs.mcgill.ca).    *
  22.  *  Copyright (c) 1995 Sergei Savchenko.                  *
  23.  *  THIS SOURCE CODE CAN'T BE USED FOR COMERCIAL PURPOSES *
  24.  *  WITHOUT AUTHORISATION                                 *
  25. \**********************************************************/
  26.  
  27. #include <math.h>                           /* sin & cos */
  28.  
  29. #ifdef __MWERKS__
  30. #include "hardware.h"           /* 32bit int name */
  31. #include "trans.h"                 /* 3D mathematics */
  32. #else
  33. #include "../hardware/hardware.h"           /* 32bit int name */
  34. #include "../trans/trans.h"                 /* 3D mathematics */
  35. #endif
  36.  
  37. typedef signed_32_bit fixed;                /* better be 32bit machine */
  38.  
  39. #define T_RADS                  40.7436642  /* pseudo-grads into rads */
  40. #define T_P                             14  /* fixed math precision */
  41.  
  42. fixed T_wx1,T_wx2,T_wx3,T_wy1,T_wy2,T_wy3,T_wz1,T_wz2,T_wz3;
  43. fixed T_sx1,T_sx2,T_sx3,T_sy1,T_sy2,T_sy3,T_sz1,T_sz2,T_sz3;
  44. fixed T_sin[256],T_cos[256];                /* precalculated */
  45.  
  46. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * *\ 
  47.  *  INTERNAL: Converting [-1,1] float into fixed.        *
  48.  *  ---------                                            *
  49. \* * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  50.  
  51. fixed TI_float2fixed(float a)
  52. { 
  53.  fixed res=0;
  54.  int i,dv,sign;
  55.  
  56.  if((sign=a<0.0)==1) a=-a;
  57.  
  58.  for(i=1,dv=2;i<=T_P;i++,dv*=2)
  59.   if(a>=1.0/dv) { a-=1.0/dv; res|=(0x1<<(T_P-i)); };
  60.  
  61.  if(sign==1) res=-res;
  62.  
  63.  return(res);
  64. }
  65.  
  66. /**********************************************************\
  67.  *  Initializing tables.                                  *
  68. \**********************************************************/
  69.  
  70. void T_init_math(void)
  71. {
  72.  int i;
  73.  
  74.  for(i=0;i<256;i++)
  75.  {
  76.   T_sin[i]=TI_float2fixed(sin(i/T_RADS));
  77.   T_cos[i]=TI_float2fixed(cos(i/T_RADS));
  78.  }
  79. } 
  80.  
  81. /**********************************************************\
  82.  *  Translation of coordinates.                           *
  83. \**********************************************************/
  84.  
  85. void T_translation(register int *from,register int *to,int length,
  86.            int addx,int addy,int addz
  87.           )
  88. {
  89.  register int i;
  90.  
  91.  for(i=0;i<length;i++)
  92.  {
  93.   (*to++)=(*from++)+addx;
  94.   (*to++)=(*from++)+addy;
  95.   (*to++)=(*from++)+addz;                   /* translation */
  96.  }
  97. }
  98.  
  99. /**********************************************************\
  100.  *  Scaling coordinates. (takes in float parameters).     *
  101. \**********************************************************/
  102.  
  103. void T_scaling(register int *from,register int *to,int length,
  104.            int mulx,int muly,int mulz
  105.           )
  106. {
  107.  register int i;
  108.  
  109.  for(i=0;i<length;i++)
  110.  {
  111.   (*to++)=(int)(*from++)*mulx;
  112.   (*to++)=(int)(*from++)*muly;
  113.   (*to++)=(int)(*from++)*mulz;
  114.  }                                          /* scaling */
  115. }
  116.  
  117. /**********************************************************\
  118.  *  Constructing rotation matrix. (gam-bet-alp), rotation *
  119.  *  then pitch then roll sequence. gam-rotation, bet-pitch*
  120.  *                                 alp-roll.              *
  121.  *                                                        *
  122.  *          Y^    Z           x'=z*sin(gam)+x*cos(gam)    *
  123.  *           |   /            y'=y                        *
  124.  *           |  / alp         z'=z*cos(gam)-x*sin(gam)    *
  125.  *          /|<---+                                       *
  126.  *         | |/   |           x"=x'                       *
  127.  *  -------|-+-----------> X  y"=y'*cos(bet)-z'*sin(bet)  *
  128.  *     bet | |   __           z"=y'*sin(bet)+z'*cos(bet)  *
  129.  *         V/|   /| gam                                   *
  130.  *         /----+             x"'=y"*sin(alp)+x"*cos(alp) *
  131.  *        /  |                y"'=y"*cos(alp)-x"*sin(alp) *
  132.  *       /   |                z"'=z"                      *
  133.  *           |                                            *
  134. \**********************************************************/
  135.  
  136. void T_set_world_rotation(int alp,int bet,int gam)
  137. {
  138.  fixed cosalp,sinalp,cosbet,sinbet,cosgam,singam;
  139.  
  140.  cosalp=T_cos[alp];
  141.  sinalp=T_sin[alp];
  142.  cosbet=T_cos[bet];
  143.  sinbet=T_sin[bet];
  144.  cosgam=T_cos[gam];
  145.  singam=T_sin[gam];                         /* initializing */
  146.  
  147.  T_wx1=((singam*((sinbet*sinalp)>>T_P))>>T_P) + ((cosgam*cosalp)>>T_P);
  148.  T_wy1=((cosbet*sinalp)>>T_P);
  149.  T_wz1=((singam*cosalp)>>T_P) - ((cosgam*((sinbet*sinalp)>>T_P))>>T_P);
  150.  
  151.  T_wx2=((singam*((sinbet*cosalp)>>T_P))>>T_P) - ((cosgam*sinalp)>>T_P);
  152.  T_wy2=((cosbet*cosalp)>>T_P);
  153.  T_wz2=-((cosgam*((sinbet*cosalp)>>T_P))>>T_P) - ((singam*sinalp)>>T_P);
  154.  
  155.  T_wx3=-((singam*cosbet)>>T_P);
  156.  T_wy3=sinbet;
  157.  T_wz3=((cosgam*cosbet)>>T_P);              /* calculating the matrix */
  158. }
  159.  
  160. /**********************************************************\
  161.  *  Rotating coordinates.                                 *
  162.  *                                        |wx1 wx2 wx3|   *
  163.  *  T'=T[W]  where:  [x' y' z'] = [x y z]*|wy1 wy2 wy3|   *
  164.  *                                        |wz1 wz2 wz3|   *
  165. \**********************************************************/
  166.  
  167. void T_world_rotation(int *from,register int *to,int length)
  168. {
  169.  register int i;
  170.  register int xt,yt,zt;
  171.  
  172.  for(i=0;i<length;i++)
  173.  {
  174.   xt=*from++;
  175.   yt=*from++;
  176.   zt=*from++;
  177.  
  178.   *to++=((T_wx1*xt)>>T_P) + ((T_wy1*yt)>>T_P) + ((T_wz1*zt)>>T_P);
  179.   *to++=((T_wx2*xt)>>T_P) + ((T_wy2*yt)>>T_P) + ((T_wz2*zt)>>T_P);
  180.   *to++=((T_wx3*xt)>>T_P) + ((T_wy3*yt)>>T_P) + ((T_wz3*zt)>>T_P); 
  181.  }
  182. }
  183.  
  184. /**********************************************************\
  185.  *  Constructing rotation matrix. (alp-bet-gam), roll     *
  186.  *  then pitch then rotation sequence. gam-rotation,      *
  187.  *                                     bet-pitch, alp-roll*
  188.  *                                                        *
  189.  *          Y^    Z           x'=y*sin(alp)+x*cos(alp)    *
  190.  *           |   /            y'=y*cos(alp)-x*sin(alp)    *
  191.  *           |  / alp         z'=z                        *
  192.  *          /|<---+                                       *
  193.  *         | |/   |           x"=x'                       *
  194.  *  -------|-+-----------> X  y"=y'*cos(bet)-z'*sin(bet)  *
  195.  *     bet | |   __           z"=y'*sin(bet)+z'*cos(bet)  *
  196.  *         V/|   /| gam                                   *
  197.  *         /----+             x"'=z"*sin(gam)+x"*cos(gam) *
  198.  *        /  |                y"'=y"                      *
  199.  *       /   |                z"'=z"*cos(gam)-x"*sin(gam) *
  200.  *           |                                            *
  201. \**********************************************************/
  202.  
  203. void T_set_self_rotation(int alp,int bet,int gam)
  204. { 
  205.  fixed cosalp,sinalp,cosbet,sinbet,cosgam,singam;
  206.  
  207.  cosalp=T_cos[alp];
  208.  sinalp=T_sin[alp];
  209.  cosbet=T_cos[bet];
  210.  sinbet=T_sin[bet];
  211.  cosgam=T_cos[gam];
  212.  singam=T_sin[gam];                         /* initializing */
  213.  
  214.  T_sx1=((cosalp*cosgam)>>T_P)-((sinalp*((sinbet*singam)>>T_P))>>T_P);
  215.  T_sy1=((sinalp*cosgam)>>T_P)+((cosalp*((sinbet*singam)>>T_P))>>T_P);
  216.  T_sz1=((cosbet*singam)>>T_P);
  217.  
  218.  T_sx2=-((sinalp*cosbet)>>T_P);
  219.  T_sy2=((cosalp*cosbet)>>T_P);
  220.  T_sz2=-sinbet;
  221.  
  222.  T_sx3=-((cosalp*singam)>>T_P)-((sinalp*((sinbet*cosgam)>>T_P))>>T_P);
  223.  T_sy3=((cosalp*((sinbet*cosgam)>>T_P))>>T_P)-((sinalp*singam)>>T_P);
  224.  T_sz3=((cosbet*cosgam)>>T_P);              /* calculating the matrix */
  225. }
  226.  
  227. /**********************************************************\
  228.  *  Rotating coordinates.                                 *
  229.  *                                        |sx1 sx2 sx3|   *
  230.  *  T'=T[S]  where:  [x' y' z'] = [x y z]*|sy1 sy2 sy3|   *
  231.  *                                        |sz1 sz2 sz3|   *
  232. \**********************************************************/
  233.  
  234. void T_self_rotation(int *from,register int *to,int length)
  235. {
  236.  register int i;
  237.  register int xt,yt,zt;
  238.  
  239.  for(i=0;i<length;i++)
  240.  {
  241.   xt=*from++;
  242.   yt=*from++;
  243.   zt=*from++;
  244.  
  245.   *to++=((T_sx1*xt)>>T_P) + ((T_sy1*yt)>>T_P) + ((T_sz1*zt)>>T_P);
  246.   *to++=((T_sx2*xt)>>T_P) + ((T_sy2*yt)>>T_P) + ((T_sz2*zt)>>T_P);
  247.   *to++=((T_sx3*xt)>>T_P) + ((T_sy3*yt)>>T_P) + ((T_sz3*zt)>>T_P); 
  248.  }
  249. }
  250.  
  251. /**********************************************************\
  252.  *  Transforming to perspective, coordinates passed ase   *
  253.  *                        supposed to be both volume, and *
  254.  *                *       Z-clipped, otherwise division   *
  255.  *               /|X      by 0 or overflow can occur.     *
  256.  *              / |                                       *
  257.  *             /  |                                       *
  258.  *            *   |                                       *
  259.  *           /|X' |       X'      X                       *
  260.  *          / |   |    ------- = ---                      *
  261.  *         /  |   |     focus     Z                       *
  262.  *        *---+---+                                       *
  263.  *        0   ^   Z    X'= X*focus/Z                      *
  264.  *            |                                           *
  265.  *          focus                                         *
  266.  *                                                        *
  267.  *  ADDITIONAL FUNCTIONS: 1) changing formats:            *
  268.  *  ---------------------                                 *
  269.  *    source:       x, y ,z,a1,...,aN where N==dimension-3*
  270.  *    destanation:  x',y',  a1,...,aN                     *   
  271.  *                                                        *
  272.  *  2) performs translation to the screen centre.         *
  273. \**********************************************************/
  274.  
  275. void T_perspective(register int *from,register int *to,
  276.            int dimension,int length
  277.           )
  278. {
  279.  register int i;
  280.  
  281.  dimension-=3;                              /* other then X,Y */
  282.  
  283.  for(i=0;i<length;i++,from+=dimension,to+=dimension) 
  284.  {                                          /* Z is not being changed */
  285.   to[0]=((((long)from[0])<<T_LOG_FOCUS)/from[2])+HW_SCREEN_X_CENTRE;
  286.   to[1]=((((long)from[1])<<T_LOG_FOCUS)/from[2])+HW_SCREEN_Y_CENTRE;
  287.   HW_copy_int(from+=3,to+=2,dimension);
  288.  }
  289. }
  290.  
  291. /**********************************************************/
  292.