home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #6 / amigaacscoverdisc1998-061998.iso / games / descent / source / 2d / roller.c < prev    next >
Text File  |  1998-06-08  |  17KB  |  600 lines
  1. /*
  2. THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  3. SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  4. END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  5. ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  6. IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  7. SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  8. FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  9. CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10. AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
  11. COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. /*
  14.  * $Source: f:/miner/source/2d/rcs/roller.c $
  15.  * $Revision: 1.15 $
  16.  * $Author: john $
  17.  * $Date: 1994/10/26 23:55:54 $
  18.  * 
  19.  * bitmap scaler, roller
  20.  * 
  21.  * $Log: roller.c $
  22.  * Revision 1.15  1994/10/26  23:55:54  john
  23.  * Took out roller; Took out inverse table.
  24.  * 
  25.  * Revision 1.14  1994/05/06  12:49:48  john
  26.  * Added supertransparency; neatend things up; took out warnings.
  27.  * 
  28.  * Revision 1.13  1994/02/04  13:21:38  matt
  29.  * Took out test code
  30.  * 
  31.  * Revision 1.12  1994/02/01  17:25:31  john
  32.  * Made transparency color be 255 all the time.
  33.  * 
  34.  * Revision 1.11  1993/12/08  16:40:47  mike
  35.  * Prevent blowup bug when xright < xleft.
  36.  * 
  37.  * Revision 1.10  1993/12/07  12:32:19  john
  38.  * moved bmd_palette to gr_palette
  39.  * 
  40.  * Revision 1.9  1993/12/03  18:41:10  unknown
  41.  * Put in check for trying to render_scanline wider than compiled code.
  42.  * 
  43.  * Revision 1.8  1993/12/03  15:13:49  mike
  44.  * Fix transparency problem by moving setting of Transparency_color.
  45.  * 
  46.  * Revision 1.7  1993/12/03  12:05:13  mike
  47.  * Make compiled code bitmaps clip.
  48.  * 
  49.  * Revision 1.6  1993/12/02  18:40:38  mike
  50.  * Suppress "Too many compiled code pointers" Error.
  51.  * 
  52.  * Revision 1.5  1993/11/28  12:07:35  mike
  53.  * Fix bugs in compiled code roller
  54.  * 
  55.  * Revision 1.4  1993/11/23  13:03:17  mike
  56.  * Add compiled code roller.
  57.  * 
  58.  * Revision 1.3  1993/11/18  14:22:44  mike
  59.  * fix bugs
  60.  * 
  61.  * Revision 1.2  1993/11/17  19:01:10  mike
  62.  * Add roller.
  63.  * 
  64.  * Revision 1.1  1993/11/16  09:36:51  mike
  65.  * Initial revision
  66.  * 
  67.  * 
  68.  */
  69.  
  70.  
  71. #pragma off (unreferenced)
  72. static char rcsid[] = "$Id: roller.c 1.15 1994/10/26 23:55:54 john Exp $";
  73. #pragma on (unreferenced)
  74.  
  75.  
  76. #define COMPILED_CODE 1
  77. #define TRANSPARENCY_COLOR 255
  78.  
  79. #include <math.h>
  80. #include <limits.h>
  81. #include <stdio.h>
  82. #include <conio.h>
  83. #include <stdlib.h>
  84.  
  85. #include "mono.h"
  86. #include "fix.h"
  87. #include "3d.h"
  88. #include "gr.h"
  89. #include "error.h"
  90.  
  91. //#define USE_ROLLER 1
  92.  
  93. #ifdef USE_ROLLER
  94.  
  95. typedef struct xyuv {
  96.     fix    x,y,u,v;
  97. } xyuv;
  98.  
  99. extern grs_bitmap ** Texture;  // Array of textmaps
  100.  
  101. int    Compiled_code_width;
  102.  
  103. //int Transparency_color = TRANSPARENCY_COLOR;
  104.  
  105. // --------------------------------------------------------------------------------------
  106. //    Create 4 xyuv points at array vb4, extracting data from 3 g3s_point points in vb.
  107. //    Create 4th point using formula (p3 = p0 + p2 - p1)
  108. void create_4_points(grs_point *vb, xyuv *vb4, int width, int height)
  109. {
  110.     int    i;
  111.  
  112.     for (i=0; i<3; i++) {
  113.         vb4[i].x = vb[i].x;
  114.         vb4[i].y = vb[i].y;
  115.     }
  116.  
  117.     vb4[3].x = vb[0].x + vb[2].x - vb[1].x;
  118.     vb4[3].y = vb[0].y + vb[2].y - vb[1].y;
  119.     
  120.     //    Set u,v coordinates.
  121.     vb4[0].u = 0;
  122.     vb4[0].v = 0;
  123.  
  124.     vb4[1].u = width*F1_0 - 1;
  125.     vb4[1].v = 0;
  126.  
  127.     vb4[2].u = width*F1_0 - 1;
  128.     vb4[2].v = height*F1_0 - 1;
  129.  
  130.     vb4[3].u = 0;
  131.     vb4[3].v = height*F1_0 - 1;
  132. }
  133.  
  134.  
  135. // --------------------------------------------------------------------------------------
  136. //    Compute deltas given 4 points.  Actually, only the first three are needed.
  137. //    For du_dx, dv_dx, determine whether p1 - p0 or p2 - p1 has larger absolute value, and
  138. //    compute deltas from those two points.
  139. //    Do similarly for du_dy, dv_dy.
  140. //    If, in either x or y, the maximum has absolute value of 0, then the bitmap is
  141. //    degenerate.  Delta values of 0 are returned in those cases.
  142. void compute_deltas(xyuv *vb, int *min_y, int *max_y, int *lbind, int *rbind,
  143.     fix *du_dx, fix *dv_dx, fix *xleft, fix *uleft, fix *vleft, fix *xright,
  144.     fix *dx_dy_left, fix *du_dy_left, fix *dv_dy_left, fix *dx_dy_right, fix *du_dy_right, fix *dv_dy_right, int *min_x, int *max_x)
  145. {
  146.     int    i;
  147. //--    fix    denom;
  148.     int    min_y_ind,min_x_ind;
  149.     int    left_break_ind,right_break_ind;
  150.     float    fldenom;
  151.  
  152.     fldenom = f2fl(vb[1].x - vb[0].x) * f2fl(vb[1].y - vb[2].y) - f2fl(vb[1].y - vb[0].y) * f2fl(vb[1].x - vb[2].x);
  153.     *du_dx = fl2f(( f2fl(vb[1].u - vb[0].u) * f2fl(vb[1].y - vb[2].y) - f2fl(vb[1].y - vb[0].y) * f2fl(vb[1].u - vb[2].u)) / fldenom);
  154.     *dv_dx = fl2f(( f2fl(vb[1].v - vb[0].v) * f2fl(vb[1].y - vb[2].y) - f2fl(vb[1].y - vb[0].y) * f2fl(vb[1].v - vb[2].v)) / fldenom);
  155.  
  156.  
  157. //--    denom = fixmul(vb[1].x - vb[0].x , vb[1].y - vb[2].y) - fixmul(vb[1].y - vb[0].y , vb[1].x - vb[2].x);
  158. //--
  159. //--    //    If denom is very small, we risk overflow
  160. //--    if (abs(denom) < F1_0/2) {
  161. //--        mprintf(0,"Warning -- denom is nearly 0, bashing to 1.0.\n");
  162. //--        Int3();
  163. //--        denom = F1_0;
  164. //--    }
  165. //--
  166. //--    *du_dx = fixdiv( fixmul(vb[1].u - vb[0].u , vb[1].y - vb[2].y) - fixmul(vb[1].y - vb[0].y , vb[1].u - vb[2].u), denom );
  167. //--    *dv_dx = fixdiv( fixmul(vb[1].v - vb[0].v , vb[1].y - vb[2].y) - fixmul(vb[1].y - vb[0].y , vb[1].v - vb[2].v), denom );
  168.  
  169.     //    Compute vertex containing minimum x, y, set min_x, max_x, min_y, max_y
  170.     *min_y =   10000;
  171.     *min_x =   10000;
  172.     for (i=0; i<4; i++) {
  173.         if (f2i(vb[i].y) < *min_y) {
  174.             *min_y = f2i(vb[i].y);
  175.             min_y_ind = i;
  176.         }
  177.  
  178.         if (f2i(vb[i].x) < *min_x) {
  179.             *min_x = f2i(vb[i].x);
  180.             min_x_ind = i;
  181.         }
  182.     }
  183.  
  184.     *max_y = f2i(vb[(min_y_ind + 2) % 4].y);
  185.     *max_x = f2i(vb[(min_x_ind + 2) % 4].x);
  186.     *xleft = vb[min_y_ind].x;
  187.     *uleft = vb[min_y_ind].u;
  188.     *vleft = vb[min_y_ind].v;
  189.  
  190.     //    Check for horizontal bitmap (min_y and following vertex have same y coord integer)
  191.     left_break_ind = (min_y_ind + 3) % 4;
  192.     if (f2i(vb[(min_y_ind+1) % 4].y) == *min_y) {
  193.         right_break_ind = (min_y_ind + 2) % 4;
  194.         *xright = vb[(min_y_ind+1)%4].x;
  195.     } else {
  196.         right_break_ind = (min_y_ind + 1) % 4;
  197.         *xright = *xleft;                    // bitmap not horizontal, left and right start out the same
  198.     }
  199.  
  200.     *lbind = left_break_ind;
  201.     *rbind = right_break_ind;
  202.  
  203.     //    Compute delta x for left and right.
  204.     if (*max_y - *min_y) {
  205.         int    dy;
  206.         dy = f2i(vb[left_break_ind].y) - *min_y;
  207.         if (dy) {
  208.             *dx_dy_left = (vb[*lbind].x - *xleft)/(f2i(vb[left_break_ind].y) - *min_y);
  209.             *du_dy_left = (vb[left_break_ind].u - vb[min_y_ind].u)/(f2i(vb[left_break_ind].y) - *min_y);
  210.             *dv_dy_left = (vb[left_break_ind].v - vb[min_y_ind].v)/(f2i(vb[left_break_ind].y) - *min_y);
  211.         } else {
  212.             *dx_dy_left = 0;
  213.             *du_dy_left = 0;
  214.             *dv_dy_left = 0;
  215.         }
  216.         dy = f2i(vb[right_break_ind].y) - *min_y;
  217.         if (dy) {
  218.             *dx_dy_right = (vb[*rbind].x - *xright)/(f2i(vb[right_break_ind].y) - *min_y);
  219.             *du_dy_right = (vb[right_break_ind].u - vb[min_y_ind].u)/(f2i(vb[right_break_ind].y) - *min_y);
  220.             *dv_dy_right = (vb[right_break_ind].v - vb[min_y_ind].v)/(f2i(vb[right_break_ind].y) - *min_y);
  221.         } else {
  222.             *dx_dy_right = 0;
  223.             *du_dy_right = 0;
  224.             *dv_dy_right = 0;
  225.         }
  226.     } else {        // bitmap is one row tall, don't care about delta x
  227.         *dx_dy_left = 0;
  228.         *du_dy_left = 0;
  229.         *dv_dy_left = 0;
  230.         *dx_dy_right = 0;
  231.         *du_dy_right = 0;
  232.         *dv_dy_right = 0;
  233.     }
  234.  
  235.  
  236. }
  237.  
  238. // 8A 06                mov    al,[esi]
  239. // 3C 81                cmp    al,129
  240. // 74 02                je     skip
  241. // 88 07                mov    [edi],al
  242. // 47          skip:    inc    edi
  243. // 81 C6   00001234     add    esi,1234h
  244.  
  245. //      6    00000000  8A 1E                 mov     bl,[esi]
  246. //      7    00000002  8A 03                 mov     al,[ebx]
  247. //      8    00000004  8A 04    03             mov     al,[ebx+eax]
  248.  
  249. //      6    00000000  8A 0E                 mov     cl,[esi]
  250. //      7    00000002  8A 03                 mov     al,[ebx]
  251. //      8    00000004  8A 04    0A             mov     al,[edx+ecx]
  252. //      9    00000007  80 F9    81             cmp     cl,129
  253.  
  254. #define    mov_cl_si_1    0x8a
  255. #define    mov_cl_si_2    0x0e
  256. #define    mov_bl_si_1    0x8a
  257. #define    mov_bl_si_2    0x1e
  258. #define    mov_al_si_1    0x8a
  259. #define    mov_al_si_2    0x06
  260. #define    cmp_al_k        0x3c
  261. #define    cmp_cl_k_1    0x80
  262. #define    cmp_cl_k_2    0xf9
  263. #define    je_addr        0x74
  264. #define    mov_al_edx_ecx_1    0x8a
  265. #define    mov_al_edx_ecx_2    0x04
  266. #define    mov_al_edx_ecx_3    0x0a
  267. #define    mov_di_al_1    0x88
  268. #define    mov_di_al_2    0x07
  269. #define    add_si_k_1    0x81
  270. #define    add_si_k_2    0xc6
  271. #define    inc_di        0x47
  272. #define    ret            0xc3
  273.  
  274. #define    MAX_COMPILED_CODE_POINTERS 1000
  275. #define    MAX_COMPILED_CODE    (MAX_COMPILED_CODE_POINTERS * 15)
  276.  
  277. char    Compiled_code[MAX_COMPILED_CODE];
  278. int    Compiled_code_pointers[MAX_COMPILED_CODE_POINTERS];
  279.  
  280. // --------------------------------------------------------------------------------------
  281. // 8a 04            mov   al,[si]
  282. // 88 05            mov   [di],al
  283. // 81 c6 34 12      add   si,1234
  284. // 47               inc   di
  285. // c3               ret
  286. //    Return true if too much compiled code, else return false.
  287. int create_compiled_code(fix du_dx, fix dv_dx, int width, int min_x, int max_x)
  288. {
  289. #if COMPILED_CODE
  290.     int    x;
  291.     char    *ccp;
  292.     int    *ccpp;
  293.     int    *ccp_int;
  294.     int    delta_si;
  295.     fix    cur_u, cur_v, new_u, new_v;
  296.     int    delta_x;
  297.  
  298.     cur_u = 0;
  299.     cur_v = 0;
  300.     new_u = du_dx;
  301.     new_v = dv_dx;
  302.     ccp = Compiled_code;
  303.     ccpp = Compiled_code_pointers;
  304.  
  305.     //    Initialize all code pointers to something which will cause an exception.
  306.     for (x=0; x<MAX_COMPILED_CODE_POINTERS; x++)
  307.         Compiled_code_pointers[x] = 0xffffffff;
  308.  
  309.     if (max_x - min_x +2 >= MAX_COMPILED_CODE_POINTERS)
  310.         delta_x = MAX_COMPILED_CODE_POINTERS-1;
  311.     else
  312.         delta_x = max_x - min_x + 2;
  313.  
  314.     Compiled_code_width = delta_x;
  315.  
  316.     for (x=0; x<=delta_x; x++) {
  317.         *ccpp++ = (int) ccp;
  318.         *ccp++ = mov_cl_si_1;
  319.         *ccp++ = mov_cl_si_2;
  320.  
  321.         *ccp++ = cmp_cl_k_1;
  322.         *ccp++ = cmp_cl_k_2;
  323.         *ccp++ = TRANSPARENCY_COLOR;                //Transparency_color;            // transparency color
  324.  
  325.         *ccp++ = je_addr;
  326.         *ccp++ = 5;                // je $+5
  327.  
  328.         *ccp++ = mov_al_edx_ecx_1;
  329.         *ccp++ = mov_al_edx_ecx_2;
  330.         *ccp++ = mov_al_edx_ecx_3;
  331.  
  332.         *ccp++ = mov_di_al_1;
  333.         *ccp++ = mov_di_al_2;
  334.  
  335.         *ccp++ = add_si_k_1;
  336.         *ccp++ = add_si_k_2;
  337.  
  338.         delta_si = f2i(new_u) - f2i(cur_u) + (  f2i(new_v) - f2i(cur_v)) * width;
  339.         ccp_int = (int *)ccp;    
  340.         *ccp_int = delta_si;
  341.         ccp += sizeof(int)/sizeof(char);
  342.  
  343.         *ccp++ = inc_di;
  344.  
  345.         if (ccp - Compiled_code >= MAX_COMPILED_CODE - 15)
  346.             return 1; //Error("Too much compiled code.\n");
  347.  
  348.         if (ccpp - Compiled_code_pointers >= MAX_COMPILED_CODE_POINTERS)
  349.             return 1; //Error("Too many compiled code pointers.\n");
  350.  
  351.         cur_u = new_u;
  352.         cur_v = new_v;
  353.         new_u += du_dx;
  354.         new_v += dv_dx;
  355.     }
  356.  
  357.     *ccpp++ = (int) ccp;
  358.     *ccp = ret;
  359.  
  360.     return 0;
  361. #else
  362.     if (min_x + max_x + width + du_dx == dv_dx - 9000)
  363.         mprintf(0,"Holy smokes!");
  364.  
  365.     return 0;
  366. #endif
  367. }
  368.  
  369. int call_compiled_code(char *start_si, char *start_di, int xleft, int xright, int light_value);
  370. #pragma aux call_compiled_code parm [esi] [edi] [eax] [ebx] [edx] value [eax] modify [ecx edx] = \
  371.     "pusha"    \
  372.     "sub    ebx,eax" \
  373.     "mov    eax,Compiled_code_pointers" \
  374.     "inc    ebx"    \
  375.     "mov    ebx,Compiled_code_pointers[ebx*4]"    \
  376.     "mov    cl,[ebx]"    \
  377.     "push    ebx"    \
  378.     "push    ecx"    \
  379.     "mov    byte ptr [ebx],0c3h"    \
  380.     "sub    ecx,ecx" \
  381.     "shl    edx,8"    \
  382.     "add    edx,offset gr_fade_table" \
  383.     "call    eax"    \
  384.     "pop    ecx"    \
  385.     "pop    ebx"    \
  386.     "mov    [ebx],cl"    \
  387.     "popa"
  388.  
  389. // --------------------------------------------------------------------------------------
  390. void render_scanline(unsigned char *pixptr, int width, int y, fix xleft, fix xright, fix u, fix v, fix du_dx, fix dv_dx, int light_value)
  391. {
  392.  
  393. #if COMPILED_CODE
  394.     unsigned char *start_si, *start_di;
  395.  
  396.     if (xright - xleft < 0)
  397.         return;
  398.  
  399.     start_si = pixptr + f2i(u) + f2i(v) * width;
  400.     start_di = grd_curcanv->cv_bitmap.bm_data + grd_curcanv->cv_bitmap.bm_rowsize*y + f2i(xleft);
  401.     if (f2i(xright) - f2i(xleft) < Compiled_code_width)
  402.         call_compiled_code(start_si, start_di, f2i(xleft), f2i(xright), light_value);
  403.     else
  404.         mprintf(0,"Not calling compiled code for xleft = %i, xright = %i, width = %i\n",f2i(xleft), f2i(xright), f2i(width));
  405.  
  406.     if (du_dx + dv_dx == 3)
  407.         mprintf(0,"That's peculiar...\n");
  408. #else
  409.     int    x;
  410.  
  411.     for (x=f2i(xleft); x<f2i(xright); x++) {
  412.         int    color;
  413.  
  414.         color = *(pixptr + f2i(v)*width + f2i(u));
  415.         if (color != TRANSPARENCY_COLOR )    {                    //Transparency_color) {
  416.             gr_setcolor(color);
  417.             gr_pixel(x,y);
  418.         }
  419.         u += du_dx;
  420.         v += dv_dx;
  421.     }
  422. #endif
  423.  
  424. }
  425.  
  426. // --------------------------------------------------------------------------------------
  427. void render_bitmap(grs_bitmap *bp, xyuv *vb, int min_y, int max_y, int lbind, int rbind,
  428.     fix du_dx, fix dv_dx, fix xleft, fix uleft, fix vleft, fix xright,
  429.     fix dx_dy_left, fix du_dy_left, fix dv_dy_left, fix dx_dy_right, fix du_dy_right, fix dv_dy_right, int light_value)
  430. {
  431.     int    y;
  432.     int    lby, rby;
  433.     fix    dx_dyl,du_dyl,dv_dyl;
  434.     fix    dx_dyr,du_dyr,dv_dyr;
  435.     fix    fix_width;
  436.  
  437.     unsigned char *pixptr = bp->bm_data;
  438.     int    width = bp->bm_w;
  439.  
  440.     lby = f2i(vb[lbind].y);
  441.     rby = f2i(vb[rbind].y);
  442.  
  443.     dx_dyl = dx_dy_left;
  444.     du_dyl = du_dy_left;
  445.     dv_dyl = dv_dy_left;
  446.     dx_dyr = dx_dy_right;
  447.     du_dyr = du_dy_right;
  448.     dv_dyr = dv_dy_right;
  449.  
  450.     //    Now, render the bitmap.
  451.     if (max_y >= grd_curcanv->cv_bitmap.bm_h)
  452.         max_y = grd_curcanv->cv_bitmap.bm_h-1;
  453.  
  454.     for (y=min_y; y<=max_y; y++) {
  455.         fix u,v;
  456.         u = uleft;
  457.         v = vleft;
  458.         if (y == lby) {
  459.             dx_dy_left = dx_dyr;
  460.             du_dy_left = du_dyr;
  461.             dv_dy_left = dv_dyr;
  462.             xleft = vb[lbind].x;
  463.             uleft = vb[lbind].u;
  464.             vleft = vb[lbind].v;
  465.         }
  466.  
  467.         if (y == rby) {
  468.             dx_dy_right = dx_dyl;
  469.             xright = vb[rbind].x;
  470.         }
  471.  
  472.         fix_width = i2f(grd_curcanv->cv_bitmap.bm_w);
  473.         if (y >= 0) {
  474.             fix    txright = xright;
  475.             fix    txleft = xleft;
  476.  
  477.             if (txleft < 0) {
  478.                 u -= fixmul(txleft,du_dx);
  479.                 v -= fixmul(txleft,dv_dx);
  480.                 txleft = 0;
  481.             }
  482.             if (txright > fix_width)
  483.                 txright = fix_width-F1_0;
  484.             if ((xright > 0) && (xleft < fix_width))
  485.                 render_scanline(pixptr, width, y, txleft, txright, u, v, du_dx, dv_dx, light_value);
  486.         }
  487.  
  488.         xleft += dx_dy_left;
  489.         xright += dx_dy_right;
  490.         uleft += du_dy_left;
  491.         vleft += dv_dy_left;
  492.     }
  493.  
  494. }
  495.  
  496. // --------------------------------------------------------------------------------------
  497. //    A scaled/rotated bitmap is defined by 3 vertices, upper left, upper right, lower right
  498. void rotate_bitmap(grs_bitmap *bp, grs_point *vertbuf, int light_value)
  499. {
  500.     fix    du_dx,dv_dx;
  501.     int    min_y,max_y;
  502.     int    lbind,rbind;
  503.     fix    xleft,xright;
  504.     fix    uleft,vleft;
  505.     fix    dx_dy_left, du_dy_left, dv_dy_left, dx_dy_right, du_dy_right, dv_dy_right;
  506.     int    min_x, max_x;
  507.     //char    *pixptr = bp->bm_data;
  508.     //int    width = bp->bm_w;
  509.     
  510.     xyuv        vb[4];
  511.  
  512.     create_4_points(vertbuf, vb, bp->bm_w, bp->bm_h);
  513.  
  514.     compute_deltas(vb, &min_y, &max_y, &lbind, &rbind, &du_dx, &dv_dx, &xleft, &uleft, &vleft, &xright,
  515.             &dx_dy_left, &du_dy_left, &dv_dy_left, &dx_dy_right, &du_dy_right, &dv_dy_right, &min_x, &max_x);
  516.  
  517. //    //    Nasty, ugly, illegal hack -- set transparency color based on top 3 left pixels.
  518. //    if ((*pixptr == *(pixptr+width)) && (*pixptr == *(pixptr+1)))            // try upper left corner
  519. //        Transparency_color = *pixptr;
  520. //    else if ((*(pixptr+width-1) == *(pixptr+width-2)) && (*(pixptr+width-1) == *(pixptr+2*width-1)))    // try upper right corner
  521. //        Transparency_color = *(pixptr + width - 1);
  522. //    else
  523. //     Transparency_color = TRANSPARENCY_COLOR;
  524.  
  525.     if (max_x - min_x < MAX_COMPILED_CODE_POINTERS) {
  526.         if (!create_compiled_code(du_dx, dv_dx, bp->bm_w, min_x, max_x))
  527.             render_bitmap(bp, vb, min_y, max_y, lbind, rbind, du_dx, dv_dx, xleft, uleft, vleft, xright,
  528.                                 dx_dy_left, du_dy_left, dv_dy_left, dx_dy_right, du_dy_right, dv_dy_right, light_value);
  529.     }
  530. }
  531.  
  532. // --------------------------------------------------------------------------------------
  533. #define DEFAULT_X_SIZE 32
  534. #define DEFAULT_Y_SIZE 32
  535. #define CENTER_X 160
  536. #define CENTER_Y 100
  537.  
  538. void set_coords(grs_point *verts, float bank, float scale)
  539. {
  540.     int    i;
  541.     float    x[3],y[3];
  542.     float    sinbank,cosbank;
  543.  
  544.     cosbank = cos(bank*3.14159/180.0);
  545.     sinbank = sin(bank*3.14159/180.0);
  546.  
  547.     x[0] = -DEFAULT_X_SIZE * scale;
  548.     y[0] = -DEFAULT_Y_SIZE * scale;
  549.  
  550.     x[1] = +DEFAULT_X_SIZE * scale;
  551.     y[1] = -DEFAULT_Y_SIZE * scale;
  552.  
  553.     x[2] = +DEFAULT_X_SIZE * scale;
  554.     y[2] = +DEFAULT_Y_SIZE * scale;
  555.  
  556.     for (i=0; i<3; i++) {
  557.         verts[i].x = fl2f(x[i] * cosbank - y[i] * sinbank + CENTER_X);
  558.         verts[i].y = fl2f(x[i] * sinbank + y[i] * cosbank + CENTER_Y);
  559.     }
  560.  
  561. }
  562.  
  563. //##// --------------------------------------------------------------------------------------
  564. //##void test_rotate_bitmap(void)
  565. //##{
  566. //##    static float    bank = 0.0;
  567. //##
  568. //##    grs_point    verts[3];
  569. //##
  570. //##    bank += 4.0;
  571. //##
  572. //##    set_coords(verts, bank, 2*pow(sin(bank/40),2)+.8);
  573. //##
  574. //##//    verts[0].x = 50 * F1_0;
  575. //##//    verts[0].y = 50 * F1_0;
  576. //##//
  577. //##//    verts[1].x = 150 * F1_0;
  578. //##//    verts[1].y = 80 * F1_0;
  579. //##//
  580. //##//    verts[2].x = 180 * F1_0;
  581. //##//    verts[2].y = 120 * F1_0;
  582. //##
  583. //##    rotate_bitmap(Texture[36],verts, 15);
  584. //##}
  585.  
  586. #else
  587.  
  588. void rotate_bitmap(grs_bitmap *bp, grs_point *vertbuf, int light_value)
  589. {
  590.     bp = bp;
  591.     vertbuf = vertbuf;
  592.     light_value = light_value;
  593.     
  594.     Int3();            // ROLLER IS IFDEF'D OUT !!!!!!!
  595. }
  596.  
  597.  
  598. #endif         // USE_ROLLER
  599. 
  600.