home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 23 / IOPROG_23.ISO / SOFT / RAYCAST.ZIP / RAYTABLE.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-19  |  5.4 KB  |  211 lines
  1. #include "fixed.h"
  2. #include "ray.h"
  3. #include "globals.h"
  4. #include <stddef.h>
  5. #include <math.h>
  6. #include "verttan.h"
  7.  
  8. void    Build_Light_Tables();
  9. void    Build_Movement_Table();
  10. void    Build_Middle_Table();
  11. long    floatRound(float f);      
  12.  
  13. inline MYFIXED Get_Angle_Difference_MYFIXED(MYFIXED angle1, MYFIXED angle2)
  14. {
  15.    MYFIXED temp_angle=angle1-angle2;
  16.    if (temp_angle < 0) {
  17.       temp_angle+=(ANGLE_360 << SHIFT);
  18.    } /* endif */
  19.    return temp_angle;
  20. }
  21.  
  22. /********************* Build Tables *********************/
  23.  
  24. void Build_Tables(void)
  25. {
  26.  
  27. distance_table=NULL;
  28.  
  29. // this function builds all the look up tables for the system
  30.  
  31. int ang;
  32. float rad_angle;
  33.  
  34. // allocate memory for all look up tables
  35.  
  36. // tangent tables equivalent to slopes
  37.  
  38. tan_table     = (long  *)NewPtr(sizeof(long) * (ANGLE_360+1) );
  39. inv_tan_table = (long  *)NewPtr(sizeof(long) * (ANGLE_360+1) );
  40.  
  41. rcos_table     = (long  *)NewPtr(sizeof(long) * (ANGLE_360+1) );
  42. rsin_table = (long  *)NewPtr(sizeof(long) * (ANGLE_360+1) );
  43.  
  44. // 1/cos and 1/sin tables used to compute distance of intersection very
  45. // quickly
  46.  
  47. inv_cos_table = (long  *)NewPtr(sizeof(long) * (ANGLE_60+1) );
  48.  
  49. height_table=(MYFIXED *)NewPtr(sizeof(MYFIXED) * (MAXDIS));
  50.  
  51. //y_movement_table=(MYFIXED *)NewPtr(sizeof(MYFIXED) * (MAXDIS));
  52.  
  53. tex_mark_table=(tex_mark *)NewPtr((WINDOW_HEIGHT) * sizeof(tex_mark));
  54.  
  55. middle_table=(MYFIXED *)NewPtr(sizeof(MYFIXED) * (MAXDIS));
  56.  
  57. for (ang=ANGLE_0; ang<=ANGLE_360; ang++)
  58.     {
  59.     rad_angle = (float)((3.272e-4) + ang * 2*3.141592654/ANGLE_360);
  60.     
  61.     tan_table[ang]     = floatRound(tan(rad_angle)*ONE);
  62.     inv_tan_table[ang] = floatRound((ONE)/(tan(rad_angle)));
  63.         
  64.         rcos_table[ang]=floatRound(cos(rad_angle)*ONE);
  65.         rsin_table[ang]=floatRound(sin(rad_angle)*ONE);
  66.  
  67.     // create the sin and cosine tables to copute distances
  68.  
  69.     } // end for ang
  70.  
  71.  
  72. // Build tables used calculate wall height
  73.  
  74. Build_Height_Table();
  75.  
  76. // Build tables to hold floor movement values
  77.  
  78. Build_Movement_Table();
  79.  
  80. // Build table used for looking up+down
  81.  
  82. Build_Middle_Table();
  83.  
  84. // Build table of vertical movement of rays per unit distance
  85.  
  86. Build_Vertical_Distance_Table();
  87.  
  88. // prepare the lighting table
  89.  
  90. Build_Light_Tables();
  91.  
  92. } // end Build_Tables
  93.  
  94. /////////////////////////////////////////////////////////////////////////////
  95.  
  96. #define VT_SHIFT 16
  97.  
  98. void Build_Vertical_Distance_Table()
  99. {
  100.    MYFIXED slope_start, slope_end, slope_sum, slope_increment, temp_slope;
  101.    angle_type start_angle, end_angle;
  102.  
  103.    if (distance_table!=NULL)   // allocate the tables
  104.         DelPtr( distance_table);
  105.    distance_table=(long *)NewPtr(sizeof(long) * WINDOW_HEIGHT);
  106.  
  107.    start_angle=Get_Angle_Sum(0, VERTICAL_VIEW_RANGE/2);
  108.    end_angle=Get_Angle_Difference(0, VERTICAL_VIEW_RANGE/2);
  109.  
  110.    slope_start=tan_table[start_angle]<<(VT_SHIFT);
  111.    slope_end=tan_table[end_angle]<<(VT_SHIFT);
  112.  
  113.    slope_sum=slope_start;
  114.    slope_increment=(slope_end-slope_start)/WINDOW_HEIGHT;
  115.  
  116.    for (long index=0; index < WINDOW_HEIGHT; index++) {
  117.  
  118.       temp_slope=slope_sum+(tan_table[VERTICAL_VIEW_ANGLE]<<VT_SHIFT);
  119.       if (temp_slope==0) temp_slope=1;
  120.       if (temp_slope<0) temp_slope=-temp_slope;
  121.  
  122.       distance_table[index]=fixeddiv(ONE << VT_SHIFT, temp_slope);
  123.  
  124.       slope_sum+=slope_increment;
  125.    }
  126.  
  127. }
  128.  
  129. void Build_Movement_Table()
  130. {
  131. /*
  132.  
  133.    long tempMovement;
  134.  
  135.    if (movement_table!=NULL) 
  136.       DelPtr( movement_table);
  137.  
  138.    movement_table=(MYFIXED *)NewPtr(sizeof(MYFIXED) * MAXDIS);
  139.  
  140.    for (long index=0; index < MAXDIS; index++) {
  141.       // get the distance incrementer in the texture
  142.       tempMovement=((index*tan_table[HORIZ_VIEW_RANGE>>1])
  143.         /WINDOW_MIDDLEW);
  144.  
  145.       movement_table[index]=tempMovement;
  146.    }
  147.  
  148. */
  149.  
  150. x_inv_trans=(tan_table[HORIZ_VIEW_RANGE>>1]<<X_TRANS_SHIFT)/(WINDOW_MIDDLEW);
  151. }
  152.  
  153. void Build_Height_Table()
  154. {
  155.    long distance;
  156.    height_table[0]=0x7fff;
  157.  
  158.    y_trans=fixeddiv(WINDOW_MIDDLE << SHIFT, tan_table[VERTICAL_VIEW_RANGE >> 1]);
  159.    y_inv_trans=tan_table[VERTICAL_VIEW_RANGE >> 1] << (SLIVER_SHIFT-SHIFT);
  160.    y_inv_trans=y_inv_trans / WINDOW_MIDDLE;
  161.    y_inv_trans<<=W_TEX_SHIFT;
  162.  
  163. }
  164.  
  165. long    floatRound(float f)
  166.         {
  167.         long other;
  168.         float   some;
  169.         
  170.         other=(long)f;  
  171.         some=fabs((float)(f-other));
  172.         
  173.         if( some>=0.5)
  174.                 {
  175.                 some=1.0-some;
  176.                 some+=0.1;
  177.                 other=some+f;
  178.                 } 
  179.         return other;
  180.         }
  181.         
  182. void Build_Light_Tables()
  183. {
  184. pal_table=(Byte * *)NewPtr(16 * sizeof(Byte *));
  185. float sum_array[16];
  186. float increment_array[16];
  187. short index1, index2, index3, temp1;
  188. float temp2;
  189. for (index1=0; index1<16; index1++) {
  190.   sum_array[index1]=increment_array[index1]=((float)index1/16);
  191.   }
  192. for (index1=0; index1<16; index1++) {
  193.   pal_table[index1]=(Byte *)NewPtr(256);
  194.   for (index2=0; index2<16; index2++) {
  195.     for (index3=0; index3<16; index3++) {
  196.       if (index3==1) {
  197.          temp1=0;
  198.          temp2=index1;
  199.       } else { temp1=index3; temp2=0; }
  200.       pal_table[index1][index3*16+index2]=(temp1*16)+((Byte)(sum_array[index2]+temp2));
  201.     }
  202.   sum_array[index2]+=(increment_array[index2]);
  203.   }                                                                           
  204. }
  205. }
  206.  
  207. void Build_Middle_Table()
  208. {
  209.    vert_angle_tangent=tan_table[VERTICAL_VIEW_ANGLE];
  210. }
  211.