2d/2dsline.c

   1 /* $Id: 2dsline.c,v 1.5 2002-07-17 21:10:38 bradleyb Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 #ifdef HAVE_CONFIG_H
  16 #include <conf.h>
  17 #endif
  18
  19 #include <string.h>
  20
  21 #include "u_mem.h"
  22
  23 #include "gr.h"
  24 #include "grdef.h"
  25
  26 #ifdef __DJGPP__
  27 #include "modex.h"
  28 #include "vesa.h"
  29 #endif
  30
  31 int Gr_scanline_darkening_level = GR_FADE_LEVELS;
  32
  33 #ifndef NO_ASM
  34 # ifdef __WATCOMC__
  35 void gr_linear_darken( ubyte * dest, int darkening_level, int count, ubyte * fade_table );
  36 #  pragma aux gr_linear_darken parm [edi] [eax] [ecx] [edx] modify exact [eax ebx ecx edx edi] = \
  37 "                                       xor     ebx, ebx                                        "       \
  38 "                                       mov     bh, al                                  "  \
  39 "gld_loop:              mov     bl, [edi]                               "       \
  40 "                                       mov     al, [ebx+edx]                   "       \
  41 "                                       mov     [edi], al                               "       \
  42 "                                       inc     edi                                             "       \
  43 "                                       dec     ecx                                             "       \
  44 "                   jnz gld_loop                    "
  45
  46 # elif defined __GNUC__
  47 static inline void gr_linear_darken( ubyte * dest, int darkening_level, int count, ubyte * fade_table ) {
  48    int dummy[4];
  49    __asm__ __volatile__ (
  50 "               xorl %%ebx, %%ebx;"
  51 "               movb %%al, %%bh;"
  52 "0:             movb (%%edi), %%bl;"
  53 "               movb (%%ebx, %%edx), %%al;"
  54 "               movb %%al, (%%edi);"
  55 "               incl %%edi;"
  56 "               decl %%ecx;"
  57 "               jnz 0b"
  58    : "=D" (dummy[0]), "=a" (dummy[1]), "=c" (dummy[2]), "=d" (dummy[3])
  59    : "0" (dest), "1" (darkening_level), "2" (count), "3" (fade_table)
  60    : "%ebx");
  61 }
  62 # elif defined _MSC_VER
  63 __inline void gr_linear_darken( ubyte * dest, int darkening_level, int count, ubyte * fade_table )
  64 {
  65   __asm {
  66     mov edi,[dest]
  67         mov eax,[darkening_level]
  68         mov ecx,[count]
  69         mov edx,[fade_table]
  70         xor ebx, ebx
  71         mov bh, al
  72 gld_loop:
  73         mov bl,[edi]
  74         mov al,[ebx+edx]
  75         mov [edi],al
  76         inc edi
  77         dec ecx
  78         jnz gld_loop
  79   }
  80 }
  81 # else
  82 // Unknown compiler. So we use C rather than inline assembler.
  83 #  define USE_C_GR_LINEAR_DARKEN 1
  84 # endif
  85
  86 #else // No Assembler. So we use C.
  87 # define USE_C_GR_LINEAR_DARKEN 1
  88 void gr_linear_stosd( ubyte * dest, unsigned char color, unsigned int nbytes) {
  89         memset(dest,color,nbytes);
  90 }
  91 #endif
  92
  93 #ifdef USE_C_GR_LINEAR_DARKEN
  94 void gr_linear_darken(ubyte * dest, int darkening_level, int count, ubyte * fade_table) {
  95         register int i;
  96
  97         for (i=0;i<count;i++)
  98                 *dest=fade_table[(*dest++)+(darkening_level*256)];
  99 }
 100 #endif
 101
 102 void gr_uscanline( int x1, int x2, int y )
 103 {
 104         if (Gr_scanline_darkening_level >= GR_FADE_LEVELS )     {
 105 #ifdef __DJGPP__
 106                 switch(TYPE)
 107                 {
 108                 case BM_LINEAR:
 109 #endif
 110                         gr_linear_stosd( DATA + ROWSIZE*y + x1, (unsigned char)COLOR, x2-x1+1);
 111 #ifdef __DJGPP__
 112                         break;
 113                 case BM_MODEX:
 114                         gr_modex_uscanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 115                         break;
 116                 case BM_SVGA:
 117                         gr_vesa_scanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 118                         break;
 119                 }
 120 #endif
 121         } else {
 122 #ifdef __DJGPP__
 123                 switch(TYPE)
 124                 {
 125                 case BM_LINEAR:
 126 #endif
 127                         gr_linear_darken( DATA + ROWSIZE*y + x1, Gr_scanline_darkening_level, x2-x1+1, gr_fade_table);
 128 #ifdef __DJGPP__
 129                         break;
 130                 case BM_MODEX:
 131                         gr_modex_uscanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 132                         break;
 133                 case BM_SVGA:
 134                         gr_vesa_scanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 135                         break;
 136                 }
 137 #endif
 138         }
 139 }
 140
 141 void gr_scanline( int x1, int x2, int y )
 142 {
 143         if ((y<0)||(y>MAXY)) return;
 144
 145         if (x2 < x1 ) x2 ^= x1 ^= x2;
 146
 147         if (x1 > MAXX) return;
 148         if (x2 < MINX) return;
 149
 150         if (x1 < MINX) x1 = MINX;
 151         if (x2 > MAXX) x2 = MAXX;
 152
 153         if (Gr_scanline_darkening_level >= GR_FADE_LEVELS )     {
 154 #ifdef __DJGPP__
 155                 switch(TYPE)
 156                 {
 157                 case BM_LINEAR:
 158 #endif
 159                         gr_linear_stosd( DATA + ROWSIZE*y + x1, (unsigned char)COLOR, x2-x1+1);
 160 #ifdef __DJGPP__
 161                         break;
 162                 case BM_MODEX:
 163                         gr_modex_uscanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 164                         break;
 165                 case BM_SVGA:
 166                         gr_vesa_scanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 167                         break;
 168                 }
 169 #endif
 170         } else {
 171 #ifdef __DJGPP__
 172                 switch(TYPE)
 173                 {
 174                 case BM_LINEAR:
 175 #endif
 176                         gr_linear_darken( DATA + ROWSIZE*y + x1, Gr_scanline_darkening_level, x2-x1+1, gr_fade_table);
 177 #ifdef __DJGPP__
 178                         break;
 179                 case BM_MODEX:
 180                         gr_modex_uscanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 181                         break;
 182                 case BM_SVGA:
 183                         gr_vesa_scanline( x1+XOFFSET, x2+XOFFSET, y+YOFFSET, COLOR );
 184                         break;
 185                 }
 186 #endif
 187         }
 188 }