arch/win32/palw32.c

   1 #include "gr.h"
   2 #include "grdef.h"
   3 #include "palette.h"
   4
   5 #include <ddraw.h>
   6
   7
   8 //added on 7/11/99 by adb to fix palette problem
   9 #undef min
  10 static __inline int min(int x, int y) { return x < y ? x : y; }
  11 //end additions - adb
  12
  13 static int last_r=0, last_g=0, last_b=0;
  14
  15 extern void Win32_DoSetPalette(PALETTEENTRY *rgpe);
  16 extern void Win32_DoGetPalette(PALETTEENTRY *rgpe);
  17 extern void Win32_MakePalVisible(void);
  18
  19 void gr_palette_step_up( int r, int g, int b )
  20 {
  21         int i;
  22         ubyte *p;
  23         int temp;
  24
  25         PALETTEENTRY pe[256];
  26
  27         if (gr_palette_faded_out) return;
  28
  29         if ( (r==last_r) && (g==last_g) && (b==last_b) ) return;
  30
  31         last_r = r;
  32         last_g = g;
  33         last_b = b;
  34
  35         p=gr_palette;
  36         for (i=0; i<256; i++)
  37         {
  38                 temp = (int)(*p++) + r;
  39                 if (temp<0) temp=0;
  40                         else if (temp>63) temp=63;
  41                 pe[i].peRed = min(temp + gr_palette_gamma, 63) * 4;
  42                 temp = (int)(*p++) + g;
  43                 if (temp<0) temp=0;
  44                         else if (temp>63) temp=63;
  45                 pe[i].peGreen = min(temp + gr_palette_gamma, 63) * 4 ;
  46                 temp = (int)(*p++) + b;
  47                 if (temp<0) temp=0;
  48                         else if (temp>63) temp=63;
  49                 pe[i].peBlue = min(temp + gr_palette_gamma, 63) * 4;
  50                 pe[i].peFlags = 0;
  51         }
  52         Win32_DoSetPalette (pe);
  53 }
  54
  55 void gr_palette_clear()
  56 {
  57         int i;
  58
  59         PALETTEENTRY pe[256];
  60         for (i=0;i<256;i++)
  61         {
  62                 pe[i].peRed=pe[i].peGreen=pe[i].peBlue=pe[i].peFlags=0;
  63         }
  64
  65         Win32_DoSetPalette (pe);
  66
  67         gr_palette_faded_out = 1;
  68 }
  69
  70 void gr_palette_load( ubyte *pal )
  71 {
  72         int i, j;
  73         PALETTEENTRY pe[256];
  74
  75         for (i=0; i<768; i++ ) {
  76                 //gr_current_pal[i] = pal[i] + gr_palette_gamma;
  77                 //if (gr_current_pal[i] > 63) gr_current_pal[i] = 63;
  78                 gr_current_pal[i] = pal[i];
  79         }
  80         for (i=0,j=0;j<256;j++)
  81         {
  82                 pe[j].peRed = min(gr_current_pal[i++] + gr_palette_gamma, 63) * 4;
  83                 pe[j].peGreen= min(gr_current_pal[i++] + gr_palette_gamma, 63) * 4;
  84                 pe[j].peBlue = min(gr_current_pal[i++] + gr_palette_gamma, 63) * 4;
  85                 pe[j].peFlags = 0;
  86         }
  87         Win32_DoSetPalette (pe);
  88
  89         gr_palette_faded_out = 0;
  90         init_computed_colors();
  91 }
  92
  93 int gr_palette_fade_out(ubyte *pal, int nsteps, int allow_keys )
  94 {
  95         int i,j,k;
  96         fix fade_palette[768];
  97         fix fade_palette_delta[768];
  98         PALETTEENTRY pe[256];
  99
 100         allow_keys  = allow_keys;
 101
 102         if (gr_palette_faded_out) return 0;
 103
 104         if (pal==NULL) pal=gr_current_pal;
 105
 106         for (i=0; i<768; i++ )
 107         {
 108                 gr_current_pal[i] = pal[i];
 109                 fade_palette[i] = i2f(pal[i]);
 110                 fade_palette_delta[i] = fade_palette[i] / nsteps;
 111         }
 112
 113         for (j=0; j<nsteps; j++ )
 114         {
 115                 for (i=0, k = 0; k < 256; k++)
 116                 {
 117                         fade_palette[i] -= fade_palette_delta[i];
 118                         if (fade_palette[i] < 0 )
 119                                 fade_palette[i] = 0;
 120                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma) )
 121                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
 122
 123                         pe[k].peRed = min(f2i(fade_palette[i]), 63) * 4;
 124                         i++;
 125                         fade_palette[i] -= fade_palette_delta[i];
 126                         if (fade_palette[i] < 0 )
 127                                 fade_palette[i] = 0;
 128                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma) )
 129                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
 130
 131                         pe[k].peGreen = min(f2i(fade_palette[i]), 63) * 4;
 132                         i++;
 133                         fade_palette[i] -= fade_palette_delta[i];
 134                         if (fade_palette[i] < 0 )
 135                                 fade_palette[i] = 0;
 136                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma) )
 137                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
 138
 139                         pe[k].peBlue = min(f2i(fade_palette[i]), 63) * 4;
 140                         pe[k].peFlags = 0;
 141                         i++;
 142                 }
 143
 144                 Win32_DoSetPalette (pe);
 145                 Win32_MakePalVisible ();
 146         }
 147
 148         gr_palette_faded_out = 1;
 149         return 0;
 150 }
 151
 152 int gr_palette_fade_in(ubyte *pal, int nsteps, int allow_keys)
 153 {
 154         int i,j, k;
 155 //      ubyte c;
 156         fix fade_palette[768];
 157         fix fade_palette_delta[768];
 158
 159         PALETTEENTRY pe[256];
 160
 161         allow_keys  = allow_keys;
 162
 163         if (!gr_palette_faded_out) return 0;
 164
 165         if (pal==NULL) pal=gr_current_pal;
 166
 167
 168         for (i=0; i<768; i++ )  {
 169                 gr_current_pal[i] = pal[i];
 170                 fade_palette[i] = 0;
 171                 fade_palette_delta[i] = i2f(pal[i]) / nsteps;
 172         }
 173
 174         for (j=0; j<nsteps; j++ )       {
 175                 for (i=0, k = 0; k<256; k++ )   {
 176                         fade_palette[i] += fade_palette_delta[i];
 177                         if (fade_palette[i] < 0 )
 178                                 fade_palette[i] = 0;
 179                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma) )
 180                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
 181
 182                         pe[k].peRed = min(f2i(fade_palette[i]), 63) * 4;
 183                         i++;
 184                         fade_palette[i] += fade_palette_delta[i];
 185                         if (fade_palette[i] < 0 )
 186                                 fade_palette[i] = 0;
 187                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma) )
 188                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
 189
 190                         pe[k].peGreen = min(f2i(fade_palette[i]), 63) * 4;
 191                         i++;
 192                         fade_palette[i] += fade_palette_delta[i];
 193                         if (fade_palette[i] < 0 )
 194                                 fade_palette[i] = 0;
 195                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma) )
 196                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma);
 197
 198                         pe[k].peBlue = min(f2i(fade_palette[i]), 63) * 4;
 199                         pe[k].peFlags = 0;
 200                         i++;
 201                 }
 202
 203                 Win32_DoSetPalette (pe);
 204                 //added on 7/11/99 by adb to allow fade in on non-palette displays
 205                 Win32_MakePalVisible ();
 206                 //end additions - adb
 207         }
 208
 209         gr_palette_faded_out = 0;
 210         return 0;
 211 }
 212
 213 void gr_palette_read(ubyte * pal)
 214 {
 215         int i;
 216 //        char c;
 217         PALETTEENTRY rgpe [256];
 218         Win32_DoGetPalette (rgpe);
 219         for (i = 0; i < 256; i++)
 220         {
 221                 *pal++ = (rgpe[i].peRed) / 4;
 222                 *pal++ = (rgpe[i].peGreen) / 4;
 223                 *pal++ = (rgpe[i].peBlue) / 4;
 224         }
 225 }