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