arch/svgalib/vid.c

   1 /*
   2  *
   3  * SVGALib video functions
   4  *
   5  *
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include <conf.h>
  10 #endif
  11
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <vga.h>
  16 #include <vgagl.h>
  17 #include "gr.h"
  18 #include "grdef.h"
  19 #include "palette.h"
  20 #include "u_mem.h"
  21 #include "error.h"
  22 #ifdef SVGALIB_INPUT
  23 #include <vgamouse.h>
  24 #endif
  25
  26 #include "gamefont.h"
  27
  28
  29 int vid_installed = 0;
  30 int usebuffer;
  31
  32 extern void mouse_handler (int button, int dx, int dy, int dz, int drx, int dry, int drz);
  33
  34 GraphicsContext *physicalscreen, *screenbuffer;
  35
  36
  37 void vid_update()
  38 {
  39         if (usebuffer)
  40                 gl_copyscreen(physicalscreen);
  41 }
  42
  43
  44 uint32_t Vid_current_mode;
  45
  46
  47 int vid_set_mode(uint32_t mode)
  48 {
  49         unsigned int w, h;
  50         char vgamode[16];
  51         vga_modeinfo *modeinfo;
  52         int modenum, rowsize;
  53         void *framebuffer;
  54
  55 #ifdef NOGRAPH
  56         return 0;
  57 #endif
  58         if (mode<=0)
  59                 return 0;
  60
  61         w=SM_W(mode);
  62         h=SM_H(mode);
  63         Vid_current_mode = mode;
  64
  65         gr_palette_clear();
  66
  67         sprintf(vgamode, "G%dx%dx256", w, h);
  68         modenum = vga_getmodenumber(vgamode);
  69         vga_setmode(modenum);
  70 #ifdef SVGALIB_INPUT
  71         mouse_seteventhandler(mouse_handler);
  72 #endif
  73         modeinfo = vga_getmodeinfo(modenum);
  74
  75         if (modeinfo->flags & CAPABLE_LINEAR)
  76         {
  77                 usebuffer = 0;
  78
  79                 vga_setlinearaddressing();
  80
  81                 // Set up physical screen only
  82                 gl_setcontextvga(modenum);
  83                 physicalscreen = gl_allocatecontext();
  84                 gl_getcontext(physicalscreen);
  85                 screenbuffer = physicalscreen;
  86
  87                 framebuffer = physicalscreen->vbuf;
  88                 rowsize = physicalscreen->bytewidth;
  89         }
  90         else
  91         {
  92                 usebuffer = 1;
  93
  94                 // Set up the physical screen
  95                 gl_setcontextvga(modenum);
  96                 physicalscreen = gl_allocatecontext();
  97                 gl_getcontext(physicalscreen);
  98
  99                 // Set up the virtual screen
 100                 gl_setcontextvgavirtual(modenum);
 101                 screenbuffer = gl_allocatecontext();
 102                 gl_getcontext(screenbuffer);
 103
 104                 framebuffer = screenbuffer->vbuf;
 105                 rowsize = screenbuffer->bytewidth;
 106         }
 107
 108         //gamefont_choose_game_font(w,h);
 109
 110         return gr_init_screen(BM_LINEAR, w, h, 0, 0, rowsize, framebuffer);
 111 }
 112
 113
 114 int vid_init(void)
 115 {
 116         int retcode;
 117         int mode = SM(320,200);
 118
 119         // Only do this function once!
 120         if (vid_installed == 1)
 121                 return -1;
 122
 123         vga_init();
 124
 125         if ((retcode = gr_set_mode(mode)))
 126                 return retcode;
 127
 128         vid_installed = 1;
 129         atexit(vid_close);
 130         return 0;
 131 }
 132
 133
 134 void vid_close(void)
 135 {
 136         if (vid_installed == 1) {
 137                 vid_installed = 0;
 138                 free(grd_curscreen);
 139                 gl_freecontext(screenbuffer);
 140                 gl_freecontext(physicalscreen);
 141         }
 142 }
 143
 144 // Palette functions follow.
 145
 146 static int last_r=0, last_g=0, last_b=0;
 147
 148 void gr_palette_clear ()
 149 {
 150         int colors[768];
 151
 152         memset (colors, 0, 768 * sizeof(int));
 153         vga_setpalvec (0, 256, colors);
 154
 155         gr_palette_faded_out = 1;
 156 }
 157
 158
 159 void gr_palette_step_up (int r, int g, int b)
 160 {
 161         int i = 0;
 162         ubyte *p = gr_palette;
 163         int temp;
 164
 165         int colors[768];
 166
 167         if (gr_palette_faded_out) return;
 168
 169         if ((r==last_r) && (g==last_g) && (b==last_b)) return;
 170
 171         last_r = r;
 172         last_g = g;
 173         last_b = b;
 174
 175         while (i < 768)
 176         {
 177                 temp = (int)(*p++) + r + gr_palette_gamma.intval;
 178                 if (temp<0) temp=0;
 179                 else if (temp>63) temp=63;
 180                 colors[i++] = temp;
 181                 temp = (int)(*p++) + g + gr_palette_gamma.intval;
 182                 if (temp<0) temp=0;
 183                 else if (temp>63) temp=63;
 184                 colors[i++] = temp;
 185                 temp = (int)(*p++) + b + gr_palette_gamma.intval;
 186                 if (temp<0) temp=0;
 187                 else if (temp>63) temp=63;
 188                 colors[i++] = temp;
 189         }
 190         vga_setpalvec (0, 256, colors);
 191 }
 192
 193 //added on 980913 by adb to fix palette problems
 194 // need a min without side effects...
 195 #undef min
 196 static inline int min(int x, int y) { return x < y ? x : y; }
 197 //end changes by adb
 198
 199 void gr_palette_load (ubyte *pal)
 200 {
 201         int i;
 202         int colors[768];
 203
 204         for (i = 0; i < 768; i++)
 205         {
 206                 gr_current_pal[i] = pal[i];
 207                 if (gr_current_pal[i] > 63) gr_current_pal[i] = 63;
 208                 colors[i] = (min(gr_current_pal[i] + gr_palette_gamma.intval, 63));
 209         }
 210
 211         vga_setpalvec (0, 256, colors);
 212
 213         gr_palette_faded_out = 0;
 214         init_computed_colors();
 215 }
 216
 217
 218
 219 int gr_palette_fade_out (ubyte *pal, int nsteps, int allow_keys)
 220 {
 221         int i, j;
 222         ubyte c;
 223         fix fade_palette[768];
 224         fix fade_palette_delta[768];
 225
 226         int fade_colors[768];
 227
 228         if (gr_palette_faded_out) return 0;
 229
 230         if (pal==NULL) pal=gr_current_pal;
 231
 232         for (i=0; i<768; i++)
 233         {
 234                 gr_current_pal[i] = pal[i];
 235                 fade_palette[i] = i2f(pal[i]);
 236                 fade_palette_delta[i] = fade_palette[i] / nsteps;
 237         }
 238
 239         for (j=0; j<nsteps; j++)
 240         {
 241                 for (i = 0; i < 768; i++)
 242                 {
 243                         fade_palette[i] -= fade_palette_delta[i];
 244                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma.intval))
 245                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma.intval);
 246                         c = f2i(fade_palette[i]);
 247                         if (c > 63) c = 63;
 248                         fade_colors[i] = c;
 249                 }
 250                 vga_setpalvec (0, 256, fade_colors);
 251         }
 252
 253         gr_palette_faded_out = 1;
 254         return 0;
 255 }
 256
 257
 258
 259 int gr_palette_fade_in (ubyte *pal, int nsteps, int allow_keys)
 260 {
 261         int i, j;
 262         ubyte c;
 263         fix fade_palette[768];
 264         fix fade_palette_delta[768];
 265
 266         int fade_colors[768];
 267
 268         if (!gr_palette_faded_out) return 0;
 269
 270         for (i=0; i<768; i++)
 271         {
 272                 gr_current_pal[i] = pal[i];
 273                 fade_palette[i] = 0;
 274                 fade_palette_delta[i] = i2f(pal[i] + gr_palette_gamma.intval) / nsteps;
 275         }
 276
 277         for (j=0; j<nsteps; j++ )
 278         {
 279                 for (i = 0; i < 768; i++ )
 280                 {
 281                         fade_palette[i] += fade_palette_delta[i];
 282                         if (fade_palette[i] > i2f(pal[i] + gr_palette_gamma.intval))
 283                                 fade_palette[i] = i2f(pal[i] + gr_palette_gamma.intval);
 284                         c = f2i(fade_palette[i]);
 285                         if (c > 63) c = 63;
 286                         fade_colors[i] = c;
 287                 }
 288                 vga_setpalvec (0, 256, fade_colors);
 289         }
 290
 291         gr_palette_faded_out = 0;
 292         return 0;
 293 }
 294
 295
 296
 297 void gr_palette_read (ubyte *pal)
 298 {
 299         int colors[768];
 300         int i;
 301
 302         vga_getpalvec (0, 256, colors);
 303
 304         for (i = 0; i < 768; i++)
 305                 pal[i] = colors[i];
 306 }